/* File : nidaqmx.i */
%module nidaqmx
%{
#include <NIDAQmx.h>
%}
%include <windows.i>
//%include <typemaps.i>
%include <exception.i>
%include <nidaqmx_const.i>
%feature("autodoc", "0");

typedef uInt32*              TaskHandle;

/* Set a default for the 'reserved' argument, so I can omit it in Python calls*/
%typemap(default) bool32 *reserved { $1 = NULL; }

/**********************************************************************
 * Convert DAQmx return codes to Exceptions
 **********************************************************************/
%exception {
    $action
    if ( DAQmxFailed(result) ) { RaiseError(); SWIG_fail; }
}
%{
    static void RaiseError() {
        char errBuff[2048]={'\0'};
        DAQmxGetExtendedErrorInfo(errBuff,2048);
        SWIG_exception(SWIG_RuntimeError, errBuff);
        fail:
        return;
    }
%}
/**********************************************************************
 * Enable Creation and Deletion of TaskHandles
 **********************************************************************/
%typemap(in, numinputs=0) TaskHandle *OUTPUT ($*1_type temp) {
    $1 = &temp;
}
%typemap(argout) TaskHandle *OUTPUT {
    $result = SWIG_NewPointerObj(SWIG_as_voidptr(*$1), $*1_descriptor, 0 );
}
%feature("autodoc", "handle = CreateTask(taskName)") DAQmxCreateTask;
%feature("autodoc", "handle = StopTask(handle)") DAQmxStopTask;

/**********************************************************************
 * Enable return of basic data types
 **********************************************************************/
%typemap(in, numinputs=0) uInt32 *data ($*1_type temp), 
        int32 *data ($*1_type temp), float64 *data ($*1_type temp) {
    $1 = &temp;
}
%typemap(argout) uInt32 *data, int32 *data, float64 *data {
    $result = SWIG_From_long(*$1);
}
//TODO: %feature("autodoc", "handle = CreateTask(taskName)") DAQmxCreateTask;

/**********************************************************************
 * Allow DAQmxWrite* to accept lists
 **********************************************************************/
//Convert a list to an Integer array for output
%typemap(in) uInt8 writeArray[] {
    Py_ssize_t sz, i;
    $*1_type *lst_ptr;
    
    sz = PyList_Size($input);
    lst_ptr = $1 = ($*1_type *) malloc(sizeof($*1_type)*sz);
    
    for (i = 0; i < sz; i++, lst_ptr++) {
        PyObject *s = PyList_GetItem($input,i);
        if (!PyInt_Check(s)) {
            free($1);
            PyErr_SetString(PyExc_ValueError, "List items must be an Int");
            return NULL;
        }
        *lst_ptr = PyInt_AsLong(s);
    }
}
%typemap(freearg) uInt8 writeArray[] {
   if ($1) free($1);
}

/* Copy all three typemap modes (in,argout, and freearg) the other integer types */
%apply uInt8 writeArray[] { int16 writeArray[] };
%apply uInt8 writeArray[] { int32 writeArray[] };
%apply uInt8 writeArray[] { uInt16 writeArray[] };
%apply uInt8 writeArray[] { uInt32 writeArray[] };

//Repeat for float64
%typemap(in) float64 writeArray[] {
    Py_ssize_t sz, i;
    $*1_type *lst_ptr;
    
    sz = PyList_Size($input);
    lst_ptr = $1 = ($*1_type *) malloc(sizeof($*1_type)*sz);
    if ($1 == NULL) {
        PyErr_NoMemory();
        SWIG_fail;
    }

    for (i = 0; i < sz; i++, lst_ptr++) {
        PyObject *s = PyList_GetItem($input,i);
        if (!PyFloat_Check(s)) {
            free($1);
            PyErr_SetString(PyExc_ValueError, "All list items must be Floats");
            return NULL;
        }
        *lst_ptr = PyFloat_AsDouble(s);
    }
}
%typemap(freearg) float64 writeArray[] {
   if ($1) free($1);
}

//Do not require sampsPerChanWritten as an input
%typemap(in, numinputs=0) int32 *sampsPerChanWritten ($*1_type temp) {
    $1 = &temp;
}
//Instead make sampsPerChanWritten the return value
%typemap(argout) int32 *sampsPerChanWritten {
    $result = PyInt_FromLong(*$1);
}

/**********************************************************************
 * Allow DAQmxRead* to return data as lists
 **********************************************************************/

/* Don't require sampsPerChanRead as an input argument. In fact, this
 * information will be discarded.
 */
%typemap(in, numinputs=0) int32 *sampsPerChanRead ($*1_type tmp) {
    $1 = &tmp;
}

/* Don't require readArray as an input argument
 * Instead, use arraySizeInSamps to create an empty array to be filled.
 */
%typemap(in) (float64 readArray[], uInt32 arraySizeInSamps) {
    $2 = PyInt_AsLong($input);
    $1 = ($*1_type *) malloc(sizeof($*1_type)*$2);
}
%typemap(in) (int16 readArray[], uInt32 arraySizeInSamps) = (float64 readArray[], uInt32 arraySizeInSamps);

/* Build a Python list for returning the data */
%typemap(argout) (float64 readArray[], uInt32 arraySizeInSamps) {
    $2_type sz, i;
    sz = PyInt_AsLong($input);
    $result = PyList_New(sz);
    for(i=0; i < sz; i++) {
        PyList_SetItem($result, i, PyFloat_FromDouble($1[i]));
    }
    //TODO: I wish I could use PyList_FromReturn() instead, but need 
    //      task handle or channel count
}
%typemap(argout) (int16 readArray[], uInt32 arraySizeInSamps) {
    $2_type sz, i;
    sz = PyInt_AsLong($input);
    $result = PyList_New(sz);
    for(i=0; i < sz; i++) {
        /* The PyFloat_FromLong() is why I need to declare this separate
         * from the float64 declaration above */
        PyList_SetItem($result, i, PyInt_FromLong($1[i]));
    }
}
/* Release the memory allocated for the array */
%typemap(freearg) (float64 readArray[], uInt32 arraySizeInSamps) {
    free(($*1_type *) $1);
}
%typemap(freearg) (int16 readArray[], uInt32 arraySizeInSamps) = (float64 readArray[], uInt32 arraySizeInSamps);

/* Copy all three typemap modes (in,argout, and freearg) the other integer types */
%apply (int16 readArray[], uInt32 arraySizeInSamps) { (int32 readArray[], uInt32 arraySizeInSamps) };
%apply (int16 readArray[], uInt32 arraySizeInSamps) { (uInt8 readArray[], uInt32 arraySizeInSamps) };
%apply (int16 readArray[], uInt32 arraySizeInSamps) { (uInt16 readArray[], uInt32 arraySizeInSamps) };
%apply (int16 readArray[], uInt32 arraySizeInSamps) { (uInt32 readArray[], uInt32 arraySizeInSamps) };

/* Now support scalar reads */
%typemap(in, numinputs=0) float64 *value ($*1_type temp), uInt32 *value ($*1_type temp) {
    $1 = &temp;
}
%typemap(argout) float64 *value { $result = PyFloat_FromDouble(*$1);}
%typemap(argout) uInt32 *value  { $result = PyInt_FromLong(*$1);    }


/**********************************************************************
 * EveryN callback issues
 **********************************************************************/

// http://www.swig.org/Doc1.3/SWIGDocumentation.html#SWIG_nn30
%feature("autodoc", "RegisterEveryNSamplesEvent(task, everyNsamplesEventType, nSamples, options, C_callbackFunction, Python_callbackFunction) -> int32") RegisterEveryNSamplesEvent;
%feature("docstring", "Call an event every N Samples. C_callbackFunction may be EveryNCallPython_cb or ReadAnalogF64_cb. Python_callbackFunction depends on the C Callback selected.") DAQmxRegisterEveryNSamplesEvent;
%{
    //SWIG descriptor for TaskHandle.
    //TODO: Would be great to get SWIG to write this for me
    #define TaskHandleDescriptor    SWIGTYPE_p_unsigned_long
    
    /*
     * EveryNCallPython_cb is the generic function to be used with
     *  RegisterEveryNSamplesEvent. It simply assumes that callbackData
     *  is a Python function and calls that function for each event.
     * 
     * Usage in Python:
     * >> DAQmx.everyNsamplesEventType(h, DAQmx.Val_Acquired_Into_Buffer,\
     *           1000,0, DAQmx.EveryNCallPython_cb,EveryNCallback)
     * - Every time 1000 samples are read into the DAQ buffer 
     *      EveryNCallPython_cb will be called
     * - EveryNCallPython_cb then call the Python function EveryNCallback
     * - EveryNCallback is a Python function that takes the following arguments:
     *   - taskHandle - Handle of reading task
     *   - everyNsamplesEventType - Same EventType given to everyNsamplesEventType
     *   - nSamples - Number of samples expected to read from DAQ buffer
     * 
     * @param taskHandle: Handle of reading task
     * @param everyNsamplesEventType: Callback type.
     * @param nSamples: Number of samples to read
     * @param python_cb: Python Function to call with data that has been read.
     * @return: Standard DAQmx status code
     * 
     * TODO:
     * - Consider adding support for EveryNCallback or
     *   (EveryNCallback, data) in last argument of everyNsamplesEventType
     */
    int32 EveryNCallPython_cb(TaskHandle taskHandle, 
            int32 everyNsamplesEventType, uInt32 nSamples, 
            void *python_cb) {
        int32 err;            // Samples/Chan read and return error code
        PyObject *func, *arglist;   // Python callback and argument list
        PyObject *result;           // Return value from Python callback
        
        //Get a Global Interpreter Lock
        //See: http://docs.python.org/c-api/init.html#thread-state-and-the-global-interpreter-lock
        PyGILState_STATE gstate;
        gstate = PyGILState_Ensure(); 
                
        //Call the Python function
        func = (PyObject *) python_cb;
        if (!PyCallable_Check(func)) {
            SWIG_exception(SWIG_RuntimeError, "Need a callable object!");
            SWIG_fail;
        }
        arglist = Py_BuildValue("(N,l,l)",      // Build argument list
                    SWIG_NewPointerObj(SWIG_as_voidptr(taskHandle),
                        TaskHandleDescriptor, 0 ),
                    everyNsamplesEventType, nSamples);

        result = PyEval_CallObject(func,arglist); // Call Python
        
        Py_DECREF(arglist);     // Trash arglist
        if (result == NULL) {   //Check for errors in func
            err = DAQmxErrorRuntimeAborting_Routing;
            SWIG_fail;
        } else if (result) {
            err = PyLong_AsLong(result);
        }
        Py_XDECREF(result);                         // Discard result
        
        PyGILState_Release(gstate); // Release thread lock
        
        return err;
        
        fail:
            //There seems to be no way to raise a Python error
            //from here. This is the next best thing I can find:
            PyErr_Print();
            DAQmxStopTask(taskHandle);
            printf("Stopping task because of error.\n");
            return err;
    }

    /*
     * ReadAnalogF64_cb is a C callback function that can be 
     * supplied to RegisterEveryNSamplesEvent(). The goal of 
     * ReadAnalogF64_cb() is to provide fast analog reads from the DAQ.
     * 
     * Using EveryNCallPython_cb an analog read would look like this:
     * ___________C Code___________|_Python Code________
     * RegisterEveryNSamplesEvent  |
     *      \                      |
     * EveryNCallPython_cb --------|---> EveryNCallback
     *                             |      /
     * ReadAnalogF64  <------------|------
     *  \                          |
     *   ---(make list & return)---|---> EveryNCallback
     * 
     * ReadAnalogF64_cb simplifies the process to:
     * ___________C Code___________|_Python Code________
     * RegisterEveryNSamplesEvent  |
     *      \                      |
     * ReadAnalogF64_cb            |
     *  \                          |
     *   ---(make list & call)-----|---> EveryNCallback
     * 
     * Usage in Python:
     * >> DAQmx.RegisterEveryNSamplesEvent(h, DAQmx.Val_Acquired_Into_Buffer,\
     *           1000,0, DAQmx.ReadAnalogF64_cb,EveryNCallback)
     * - Every time 1000 samples are read into the DAQ buffer 
     *      ReadAnalogF64_cb will be called
     * - ReadAnalogF64_cb will read the floating point data from the 
     *      channels, using DAQmx_Val_Auto and DAQmx_Val_GroupByChannel
     * - The data will be converted to a Python list and the
     *      Python function EveryNCallback will be called with the list
     * - EveryNCallback is a Python function that takes the following arguments:
     *   - sampsPerChanRead - This is the sampsPerChanRead returned by DAQmxReadAnalogF64
     *   - dataRead - List with data read from DAQ
     * 
     * @param taskHandle: Handle of reading task
     * @param everyNsamplesEventType: Callback type. Must be DAQmx_Val_Acquired_Into_Buffer
     * @param nSamples: Number of samples to read
     * @param python_cb: Python Function to call with data that has been read.
     * @return: Standard DAQmx status code
     */
    int32 ReadAnalogF64_cb(TaskHandle taskHandle, 
            int32 everyNsamplesEventType, uInt32 nSamples, 
            void *python_cb) {
        float64 *readArray;         //Will hold the raw data read from DAQ
        PyObject *dataOut;          // Python list made from readArray
        int32 read, err;            // Samples/Chan read and return error code
        uInt32 chCnt,i;             // Channel Count, Loop Index
        PyObject *func, *arglist;   // Python callback and argument list
        PyObject *result;           // Return value from Python callback
        
        //Get a Global Interpreter Lock
        //See: http://docs.python.org/c-api/init.html#thread-state-and-the-global-interpreter-lock
        PyGILState_STATE gstate;
        gstate = PyGILState_Ensure(); 

        //Validate Event Type
        if (everyNsamplesEventType != DAQmx_Val_Acquired_Into_Buffer) {
            SWIG_exception(SWIG_ValueError, "ReadAnalogF64_cb only works for input tasks");
        } 
        
        //Determine how many channels there are in the task
        DAQmxGetReadNumChans(taskHandle, &chCnt);
        
        //Make space for data and fill the space from the DAQ buffer
        readArray = (float64 *) malloc(sizeof(float64)*nSamples*chCnt);
        if (readArray == NULL) {
            PyErr_NoMemory();
            err = DAQmxErrorRuntimeAborting_Routing;
            SWIG_fail;
        }
        err = DAQmxReadAnalogF64(taskHandle,DAQmx_Val_Auto,10.0,
            DAQmx_Val_GroupByChannel,readArray,nSamples*chCnt,&read,NULL);
        if ( DAQmxFailed(err) ) { RaiseError(); SWIG_fail; }
        
        //Convert read data to a list
        //NOTE: Use read, because it tells how much was actually read,
        //      So we can ommit empty buffer space
        //TODO: Use PyList_FromReturn() instead
        dataOut = PyList_New(read*chCnt);
        for(i=0; i < read*chCnt; i++) {
            if ( PyList_SetItem(dataOut, i, PyFloat_FromDouble(readArray[i])) != 0) { 
                if( PyErr_Occurred() != NULL) {
                    SWIG_fail; //Handle as regular Python error
                } else {
                    //Return some sort of feedback
                    printf("Assignement error for data[%d]=%f", i, readArray[i]);
                    break;
                }
            }
        }
                
        //Call the Python function
        func = (PyObject *) python_cb;
        if (!PyCallable_Check(func)) {
            SWIG_exception(SWIG_RuntimeError, "Need a callable object!");
            SWIG_fail;
        }
        arglist = Py_BuildValue("(l,O)",read, dataOut);// Build argument list

        result = PyEval_CallObject(func,arglist); // Call Python
        
        Py_DECREF(arglist);     // Trash arglist
        Py_DECREF(dataOut);     // This function doesn't need data list. Necissary?
        if (result == NULL) {   //Check for errors in func
            err = DAQmxErrorRuntimeAborting_Routing;
            SWIG_fail;
        } else if (result) {
            err = PyLong_AsLong(result);
        }
        Py_XDECREF(result);                         // Discard result
        
        PyGILState_Release(gstate); // Release thread lock
        
        free( readArray );
        return err;
        
        fail:
            free( readArray );
            //There seems to be no way to raise a Python error
            //from here. This is the next best thing I can find:
            PyErr_Print();
            DAQmxStopTask(taskHandle);
            printf("Stopping task because of error.\n");
            return err;
    }
    //TODO: Build a digital corelary to ReadDigitalU32_cb
    
    /* Take the return from DAQmxReadAnalogF64() and segment it into
     * Python lists. Note this will separate channel data into separate lists.
     * @param readArray:        Pointer to array of data read by DAQmxReadAnalogF64
     * @param sampsPerChanRead: Value of same name returned by DAQmxReadAnalogF64
     * @param chCnt:            Number of channels in this task
     * @return: If chCnt > 1: [[ch1 Data], [ch2 Data], etc.]
     *          If chCn == 1 : [ch1 Data]
     *          If error : NULL
     */
    PyObject *PyList_FromReturn(float64 *readArray,
                                int32 sampsPerChanRead, uInt32 chCnt) {
        PyObject *dataOut, *lst;
        float64 *arrPnt=readArray;
        uInt32 ch;
        int32 i;
        
        dataOut = PyList_New(chCnt);
        for(ch=0; ch < chCnt; ch++) {
            lst = PyList_New(sampsPerChanRead);
            for(i=sampsPerChanRead*ch; i < sampsPerChanRead*(ch+1); i++, arrPnt++) {
                if ( PyList_SetItem(lst, i, PyFloat_FromDouble(*arrPnt)) != 0) { 
                    if( PyErr_Occurred() != NULL) { //TODO: PyErr_Occurred == NULL but SetItem still failed?
                        SWIG_fail; //Handle as regular Python error
                    } else {
                        //Failed to raise Python error, return some sort of feedback
                        printf("Assignement error for data[%d]=%f", i, readArray[i]);
                        break;
                    }
                }
            }
            PyList_SetItem(dataOut, ch, lst);
        }
        
        if (chCnt > 1) {
            return dataOut; //List of lists
        } else {
            return lst; //Single channel, return 1D list
        }
        fail: //Error
            return NULL;
    }
%}

//Make sure EveryNCallPython_cb & ReadAnalogF64_cb show up on the Python side
%constant int32 EveryNCallPython_cb(TaskHandle, int32, uInt32, void*);
%constant int32 ReadAnalogF64_cb(TaskHandle, int32, uInt32, void*);

// Handle incoming pointer to C function callback
%typemap(in) void *callbackData {
    if (!PyCallable_Check($input)) {
        SWIG_exception(SWIG_RuntimeError, "callbackData must be a callable object.");
        SWIG_fail;
    }
    $1 = $input;
    Py_XINCREF($1); // Add a reference to new callback
}

%inline %{
    /*
     * Call_ReadAnalogF64_cb simply allows the user to call
     * ReadAnalogF64_cb directly from Python. This is primarily used
     * for testing, but may also be used to allow re-use of a Python
     * callback function for single reads.
     */
    int32 Call_ReadAnalogF64_cb(TaskHandle taskHandle, uInt32 nSamples, void *callbackData) {
        int32 err;
        err = ReadAnalogF64_cb(taskHandle, DAQmx_Val_Acquired_Into_Buffer,
         nSamples, callbackData);
    return err;
    }
%}


#ifdef __linux__
#define __CFUNC
#define __CFUNC_C
#define __CFUNCPTRVAR
#define CVICDECL
#define CVICALLBACK     CVICDECL
#else
#define __CFUNC         __stdcall
#define __CFUNC_C       __cdecl
#define __CFUNCPTRVAR   __cdecl
#define CVICDECL        __cdecl
#define CVICALLBACK     CVICDECL
#endif

#ifdef __linux__
	typedef long long int      int64;
#else
	typedef __int64            int64;
#endif
#ifdef __linux__
	typedef unsigned long long uInt64;
#else
	typedef unsigned __int64   uInt64;
#endif


/*
 * TODO:
 * - Remove the header file top comment block
 * - Deal with __linux__ remainders
 * - Remove TaskHandle def
 */

#if defined(_CVI_) && !defined(__TPC__)
#pragma EnableLibraryRuntimeChecking
#endif


// NI-DAQmx Typedefs
typedef signed char        int8;
typedef unsigned char      uInt8;
typedef signed short       int16;
typedef unsigned short     uInt16;
typedef signed long        int32;
typedef unsigned long      uInt32;
typedef float              float32;
typedef double             float64;

typedef uInt32             bool32;

typedef uInt32             CalHandle;

/* NI-DAQmx Function Declarations
 */
/** Events & Signals
 **/

// Terminology:  For hardware, "signals" comprise "clocks," "triggers," and (output) "events".
// Software signals or events are not presently supported.

// For possible values for parameter signalID see value set Signal in Values section above.
%rename(ExportSignal) DAQmxExportSignal;
int32 __CFUNC     DAQmxExportSignal                (TaskHandle taskHandle, int32 signalID, const char outputTerminal[]);

%rename(GetExportedSignalAttribute) DAQmxGetExportedSignalAttribute;
int32 __CFUNC_C   DAQmxGetExportedSignalAttribute  (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetExportedSignalAttribute) DAQmxSetExportedSignalAttribute;
int32 __CFUNC_C   DAQmxSetExportedSignalAttribute  (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetExportedSignalAttribute) DAQmxResetExportedSignalAttribute;
int32 __CFUNC     DAQmxResetExportedSignalAttribute(TaskHandle taskHandle, int32 attribute);


/** Channel Configuration/Creation
 **/


%rename(CreateAIVoltageChan) DAQmxCreateAIVoltageChan;
int32 __CFUNC     DAQmxCreateAIVoltageChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateAICurrentChan) DAQmxCreateAICurrentChan;
int32 __CFUNC     DAQmxCreateAICurrentChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);
%rename(CreateAIVoltageRMSChan) DAQmxCreateAIVoltageRMSChan;
int32 __CFUNC     DAQmxCreateAIVoltageRMSChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateAICurrentRMSChan) DAQmxCreateAICurrentRMSChan;
int32 __CFUNC     DAQmxCreateAICurrentRMSChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);
%rename(CreateAIThrmcplChan) DAQmxCreateAIThrmcplChan;
int32 __CFUNC     DAQmxCreateAIThrmcplChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 thermocoupleType, int32 cjcSource, float64 cjcVal, const char cjcChannel[]);
%rename(CreateAIRTDChan) DAQmxCreateAIRTDChan;
int32 __CFUNC     DAQmxCreateAIRTDChan              (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 rtdType, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, float64 r0);
%rename(CreateAIThrmstrChanIex) DAQmxCreateAIThrmstrChanIex;
int32 __CFUNC     DAQmxCreateAIThrmstrChanIex       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, float64 a, float64 b, float64 c);
%rename(CreateAIThrmstrChanVex) DAQmxCreateAIThrmstrChanVex;
int32 __CFUNC     DAQmxCreateAIThrmstrChanVex       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 a, float64 b, float64 c, float64 r1);
%rename(CreateAIFreqVoltageChan) DAQmxCreateAIFreqVoltageChan;
int32 __CFUNC     DAQmxCreateAIFreqVoltageChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 thresholdLevel, float64 hysteresis, const char customScaleName[]);
%rename(CreateAIResistanceChan) DAQmxCreateAIResistanceChan;
int32 __CFUNC     DAQmxCreateAIResistanceChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);
%rename(CreateAIStrainGageChan) DAQmxCreateAIStrainGageChan;
int32 __CFUNC     DAQmxCreateAIStrainGageChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 strainConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 gageFactor, float64 initialBridgeVoltage, float64 nominalGageResistance, float64 poissonRatio, float64 leadWireResistance, const char customScaleName[]);
%rename(CreateAIVoltageChanWithExcit) DAQmxCreateAIVoltageChanWithExcit;
int32 __CFUNC     DAQmxCreateAIVoltageChanWithExcit (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 bridgeConfig, int32 voltageExcitSource, float64 voltageExcitVal, bool32 useExcitForScaling, const char customScaleName[]);
%rename(CreateAITempBuiltInSensorChan) DAQmxCreateAITempBuiltInSensorChan;
int32 __CFUNC     DAQmxCreateAITempBuiltInSensorChan(TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 units);
%rename(CreateAIAccelChan) DAQmxCreateAIAccelChan;
int32 __CFUNC     DAQmxCreateAIAccelChan            (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

%rename(CreateAIMicrophoneChan) DAQmxCreateAIMicrophoneChan;
int32 __CFUNC     DAQmxCreateAIMicrophoneChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, int32 units, float64 micSensitivity, float64 maxSndPressLevel, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);
%rename(CreateAIPosLVDTChan) DAQmxCreateAIPosLVDTChan;
int32 __CFUNC     DAQmxCreateAIPosLVDTChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);
%rename(CreateAIPosRVDTChan) DAQmxCreateAIPosRVDTChan;
int32 __CFUNC     DAQmxCreateAIPosRVDTChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);
%rename(CreateAIPosEddyCurrProxProbeChan) DAQmxCreateAIPosEddyCurrProxProbeChan;
int32 __CFUNC     DAQmxCreateAIPosEddyCurrProxProbeChan(TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, float64 sensitivity, int32 sensitivityUnits, const char customScaleName[]);
%rename(CreateAIDeviceTempChan) DAQmxCreateAIDeviceTempChan;
%feature("docstring", " Function DAQmxCreateAIDeviceTempChan is obsolete and has been replaced by DAQmxCreateAITempBuiltInSensorChan") CreateAIDeviceTempChan;

%rename(CreateAIDeviceTempChan) DAQmxCreateAIDeviceTempChan;
int32 __CFUNC     DAQmxCreateAIDeviceTempChan       (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 units);

%rename(CreateTEDSAIVoltageChan) DAQmxCreateTEDSAIVoltageChan;
int32 __CFUNC     DAQmxCreateTEDSAIVoltageChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateTEDSAICurrentChan) DAQmxCreateTEDSAICurrentChan;
int32 __CFUNC     DAQmxCreateTEDSAICurrentChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 shuntResistorLoc, float64 extShuntResistorVal, const char customScaleName[]);
%rename(CreateTEDSAIThrmcplChan) DAQmxCreateTEDSAIThrmcplChan;
int32 __CFUNC     DAQmxCreateTEDSAIThrmcplChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 cjcSource, float64 cjcVal, const char cjcChannel[]);
%rename(CreateTEDSAIRTDChan) DAQmxCreateTEDSAIRTDChan;
int32 __CFUNC     DAQmxCreateTEDSAIRTDChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal);
%rename(CreateTEDSAIThrmstrChanIex) DAQmxCreateTEDSAIThrmstrChanIex;
int32 __CFUNC     DAQmxCreateTEDSAIThrmstrChanIex   (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal);
%rename(CreateTEDSAIThrmstrChanVex) DAQmxCreateTEDSAIThrmstrChanVex;
int32 __CFUNC     DAQmxCreateTEDSAIThrmstrChanVex   (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 voltageExcitSource, float64 voltageExcitVal, float64 r1);
%rename(CreateTEDSAIResistanceChan) DAQmxCreateTEDSAIResistanceChan;
int32 __CFUNC     DAQmxCreateTEDSAIResistanceChan   (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 resistanceConfig, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);
%rename(CreateTEDSAIStrainGageChan) DAQmxCreateTEDSAIStrainGageChan;
int32 __CFUNC     DAQmxCreateTEDSAIStrainGageChan   (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 initialBridgeVoltage, float64 leadWireResistance, const char customScaleName[]);
%rename(CreateTEDSAIVoltageChanWithExcit) DAQmxCreateTEDSAIVoltageChanWithExcit;
int32 __CFUNC     DAQmxCreateTEDSAIVoltageChanWithExcit (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, const char customScaleName[]);
%rename(CreateTEDSAIAccelChan) DAQmxCreateTEDSAIAccelChan;
int32 __CFUNC     DAQmxCreateTEDSAIAccelChan        (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, float64 minVal, float64 maxVal, int32 units, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);

%rename(CreateTEDSAIMicrophoneChan) DAQmxCreateTEDSAIMicrophoneChan;
int32 __CFUNC     DAQmxCreateTEDSAIMicrophoneChan   (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 terminalConfig, int32 units, float64 maxSndPressLevel, int32 currentExcitSource, float64 currentExcitVal, const char customScaleName[]);
%rename(CreateTEDSAIPosLVDTChan) DAQmxCreateTEDSAIPosLVDTChan;
int32 __CFUNC     DAQmxCreateTEDSAIPosLVDTChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);
%rename(CreateTEDSAIPosRVDTChan) DAQmxCreateTEDSAIPosRVDTChan;
int32 __CFUNC     DAQmxCreateTEDSAIPosRVDTChan      (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 voltageExcitSource, float64 voltageExcitVal, float64 voltageExcitFreq, int32 ACExcitWireMode, const char customScaleName[]);

%rename(CreateAOVoltageChan) DAQmxCreateAOVoltageChan;
int32 __CFUNC     DAQmxCreateAOVoltageChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateAOCurrentChan) DAQmxCreateAOCurrentChan;
int32 __CFUNC     DAQmxCreateAOCurrentChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateAOFuncGenChan) DAQmxCreateAOFuncGenChan;
int32 __CFUNC     DAQmxCreateAOFuncGenChan          (TaskHandle taskHandle, const char physicalChannel[], const char nameToAssignToChannel[], int32 type, float64 freq, float64 amplitude, float64 offset);

%rename(CreateDIChan) DAQmxCreateDIChan;
int32 __CFUNC     DAQmxCreateDIChan                 (TaskHandle taskHandle, const char lines[], const char nameToAssignToLines[], int32 lineGrouping);

%rename(CreateDOChan) DAQmxCreateDOChan;
int32 __CFUNC     DAQmxCreateDOChan                 (TaskHandle taskHandle, const char lines[], const char nameToAssignToLines[], int32 lineGrouping);

%rename(CreateCIFreqChan) DAQmxCreateCIFreqChan;
int32 __CFUNC     DAQmxCreateCIFreqChan             (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 edge, int32 measMethod, float64 measTime, uInt32 divisor, const char customScaleName[]);
%rename(CreateCIPeriodChan) DAQmxCreateCIPeriodChan;
int32 __CFUNC     DAQmxCreateCIPeriodChan           (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 edge, int32 measMethod, float64 measTime, uInt32 divisor, const char customScaleName[]);
%rename(CreateCICountEdgesChan) DAQmxCreateCICountEdgesChan;
int32 __CFUNC     DAQmxCreateCICountEdgesChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 edge, uInt32 initialCount, int32 countDirection);
%rename(CreateCIPulseWidthChan) DAQmxCreateCIPulseWidthChan;
int32 __CFUNC     DAQmxCreateCIPulseWidthChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 startingEdge, const char customScaleName[]);
%rename(CreateCISemiPeriodChan) DAQmxCreateCISemiPeriodChan;
int32 __CFUNC     DAQmxCreateCISemiPeriodChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, const char customScaleName[]);
%rename(CreateCITwoEdgeSepChan) DAQmxCreateCITwoEdgeSepChan;
int32 __CFUNC     DAQmxCreateCITwoEdgeSepChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], float64 minVal, float64 maxVal, int32 units, int32 firstEdge, int32 secondEdge, const char customScaleName[]);
%rename(CreateCILinEncoderChan) DAQmxCreateCILinEncoderChan;
int32 __CFUNC     DAQmxCreateCILinEncoderChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 decodingType, bool32 ZidxEnable, float64 ZidxVal, int32 ZidxPhase, int32 units, float64 distPerPulse, float64 initialPos, const char customScaleName[]);
%rename(CreateCIAngEncoderChan) DAQmxCreateCIAngEncoderChan;
int32 __CFUNC     DAQmxCreateCIAngEncoderChan       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 decodingType, bool32 ZidxEnable, float64 ZidxVal, int32 ZidxPhase, int32 units, uInt32 pulsesPerRev, float64 initialAngle, const char customScaleName[]);
%rename(CreateCIGPSTimestampChan) DAQmxCreateCIGPSTimestampChan;
int32 __CFUNC     DAQmxCreateCIGPSTimestampChan     (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 syncMethod, const char customScaleName[]);

%rename(CreateCOPulseChanFreq) DAQmxCreateCOPulseChanFreq;
int32 __CFUNC     DAQmxCreateCOPulseChanFreq        (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 idleState, float64 initialDelay, float64 freq, float64 dutyCycle);
%rename(CreateCOPulseChanTime) DAQmxCreateCOPulseChanTime;
int32 __CFUNC     DAQmxCreateCOPulseChanTime        (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], int32 units, int32 idleState, float64 initialDelay, float64 lowTime, float64 highTime);
%rename(CreateCOPulseChanTicks) DAQmxCreateCOPulseChanTicks;
int32 __CFUNC     DAQmxCreateCOPulseChanTicks       (TaskHandle taskHandle, const char counter[], const char nameToAssignToChannel[], const char sourceTerminal[], int32 idleState, int32 initialDelay, int32 lowTicks, int32 highTicks);

%rename(GetAIChanCalCalDate) DAQmxGetAIChanCalCalDate;
int32 __CFUNC     DAQmxGetAIChanCalCalDate(TaskHandle taskHandle, const char channelName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);
%rename(SetAIChanCalCalDate) DAQmxSetAIChanCalCalDate;
int32 __CFUNC     DAQmxSetAIChanCalCalDate(TaskHandle taskHandle, const char channelName[], uInt32 year, uInt32 month, uInt32 day, uInt32 hour, uInt32 minute);
%rename(GetAIChanCalExpDate) DAQmxGetAIChanCalExpDate;
int32 __CFUNC     DAQmxGetAIChanCalExpDate(TaskHandle taskHandle, const char channelName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);
%rename(SetAIChanCalExpDate) DAQmxSetAIChanCalExpDate;
int32 __CFUNC     DAQmxSetAIChanCalExpDate(TaskHandle taskHandle, const char channelName[], uInt32 year, uInt32 month, uInt32 day, uInt32 hour, uInt32 minute);

%rename(GetChanAttribute) DAQmxGetChanAttribute;
int32 __CFUNC_C   DAQmxGetChanAttribute             (TaskHandle taskHandle, const char channel[], int32 attribute, void *value, ...);
%rename(SetChanAttribute) DAQmxSetChanAttribute;
int32 __CFUNC_C   DAQmxSetChanAttribute             (TaskHandle taskHandle, const char channel[], int32 attribute, ...);
%rename(ResetChanAttribute) DAQmxResetChanAttribute;
int32 __CFUNC     DAQmxResetChanAttribute           (TaskHandle taskHandle, const char channel[], int32 attribute);


/** Buffer Configurations
 **/


%rename(CfgInputBuffer) DAQmxCfgInputBuffer;
int32 __CFUNC     DAQmxCfgInputBuffer      (TaskHandle taskHandle, uInt32 numSampsPerChan);
%rename(CfgOutputBuffer) DAQmxCfgOutputBuffer;
int32 __CFUNC     DAQmxCfgOutputBuffer     (TaskHandle taskHandle, uInt32 numSampsPerChan);

%rename(GetBufferAttribute) DAQmxGetBufferAttribute;
int32 __CFUNC_C   DAQmxGetBufferAttribute  (TaskHandle taskHandle, int32 attribute, void *value);
%rename(SetBufferAttribute) DAQmxSetBufferAttribute;
int32 __CFUNC_C   DAQmxSetBufferAttribute  (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetBufferAttribute) DAQmxResetBufferAttribute;
int32 __CFUNC     DAQmxResetBufferAttribute(TaskHandle taskHandle, int32 attribute);

/** Signal Routing
 **/


%rename(ConnectTerms) DAQmxConnectTerms;
int32 __CFUNC     DAQmxConnectTerms         (const char sourceTerminal[], const char destinationTerminal[], int32 signalModifiers);
%rename(DisconnectTerms) DAQmxDisconnectTerms;
int32 __CFUNC     DAQmxDisconnectTerms      (const char sourceTerminal[], const char destinationTerminal[]);
%rename(TristateOutputTerm) DAQmxTristateOutputTerm;
int32 __CFUNC     DAQmxTristateOutputTerm   (const char outputTerminal[]);


/** Storage
 **/

%rename(SaveTask) DAQmxSaveTask;
int32 __CFUNC     DAQmxSaveTask                    (TaskHandle taskHandle, const char saveAs[], const char author[], uInt32 options);
%rename(SaveGlobalChan) DAQmxSaveGlobalChan;
int32 __CFUNC     DAQmxSaveGlobalChan              (TaskHandle taskHandle, const char channelName[], const char saveAs[], const char author[], uInt32 options);
%rename(SaveScale) DAQmxSaveScale;
int32 __CFUNC     DAQmxSaveScale                   (const char scaleName[], const char saveAs[], const char author[], uInt32 options);
%rename(DeleteSavedTask) DAQmxDeleteSavedTask;
int32 __CFUNC     DAQmxDeleteSavedTask             (const char taskName[]);
%rename(DeleteSavedGlobalChan) DAQmxDeleteSavedGlobalChan;
int32 __CFUNC     DAQmxDeleteSavedGlobalChan       (const char channelName[]);
%rename(DeleteSavedScale) DAQmxDeleteSavedScale;
int32 __CFUNC     DAQmxDeleteSavedScale            (const char scaleName[]);

%rename(GetPersistedTaskAttribute) DAQmxGetPersistedTaskAttribute;
int32 __CFUNC_C   DAQmxGetPersistedTaskAttribute   (const char taskName[], int32 attribute, void *value, ...);
%rename(GetPersistedChanAttribute) DAQmxGetPersistedChanAttribute;
int32 __CFUNC_C   DAQmxGetPersistedChanAttribute   (const char channel[], int32 attribute, void *value, ...);
%rename(GetPersistedScaleAttribute) DAQmxGetPersistedScaleAttribute;
int32 __CFUNC_C   DAQmxGetPersistedScaleAttribute  (const char scaleName[], int32 attribute, void *value, ...);


/** Error Handling
 **/


%rename(GetErrorString) DAQmxGetErrorString;
int32 __CFUNC     DAQmxGetErrorString       (int32 errorCode, char errorString[], uInt32 bufferSize);
%rename(GetExtendedErrorInfo) DAQmxGetExtendedErrorInfo;
int32 __CFUNC     DAQmxGetExtendedErrorInfo (char errorString[], uInt32 bufferSize);


/** Scale Configurations
 **/


%rename(CreateLinScale) DAQmxCreateLinScale;
int32 __CFUNC     DAQmxCreateLinScale             (const char name[], float64 slope, float64 yIntercept, int32 preScaledUnits, const char scaledUnits[]);
%rename(CreateMapScale) DAQmxCreateMapScale;
int32 __CFUNC     DAQmxCreateMapScale             (const char name[], float64 prescaledMin, float64 prescaledMax, float64 scaledMin, float64 scaledMax, int32 preScaledUnits, const char scaledUnits[]);
%rename(CreatePolynomialScale) DAQmxCreatePolynomialScale;
int32 __CFUNC     DAQmxCreatePolynomialScale      (const char name[], const float64 forwardCoeffs[], uInt32 numForwardCoeffsIn, const float64 reverseCoeffs[], uInt32 numReverseCoeffsIn, int32 preScaledUnits, const char scaledUnits[]);
%rename(CreateTableScale) DAQmxCreateTableScale;
int32 __CFUNC     DAQmxCreateTableScale           (const char name[], const float64 prescaledVals[], uInt32 numPrescaledValsIn, const float64 scaledVals[], uInt32 numScaledValsIn, int32 preScaledUnits, const char scaledUnits[]);
%rename(CalculateReversePolyCoeff) DAQmxCalculateReversePolyCoeff;
int32 __CFUNC     DAQmxCalculateReversePolyCoeff  (const float64 forwardCoeffs[], uInt32 numForwardCoeffsIn, float64 minValX, float64 maxValX, int32 numPointsToCompute, int32 reversePolyOrder, float64 reverseCoeffs[]);

%rename(GetScaleAttribute) DAQmxGetScaleAttribute;
int32 __CFUNC_C   DAQmxGetScaleAttribute          (const char scaleName[], int32 attribute, void *value, ...);
%rename(SetScaleAttribute) DAQmxSetScaleAttribute;
int32 __CFUNC_C   DAQmxSetScaleAttribute          (const char scaleName[], int32 attribute, ...);


/** Watchdog Timer
 **/


%rename(CreateWatchdogTimerTask) DAQmxCreateWatchdogTimerTask;
int32 __CFUNC_C   DAQmxCreateWatchdogTimerTask    (const char deviceName[], const char taskName[], TaskHandle *OUTPUT, float64 timeout, const char lines[], int32 expState, ...);
%rename(ControlWatchdogTask) DAQmxControlWatchdogTask;
int32 __CFUNC     DAQmxControlWatchdogTask        (TaskHandle taskHandle, int32 action);

%rename(GetWatchdogAttribute) DAQmxGetWatchdogAttribute;
int32 __CFUNC_C  DAQmxGetWatchdogAttribute        (TaskHandle taskHandle, const char lines[], int32 attribute, void *value, ...);
%rename(SetWatchdogAttribute) DAQmxSetWatchdogAttribute;
int32 __CFUNC_C  DAQmxSetWatchdogAttribute        (TaskHandle taskHandle, const char lines[], int32 attribute, ...);
%rename(ResetWatchdogAttribute) DAQmxResetWatchdogAttribute;
int32 __CFUNC    DAQmxResetWatchdogAttribute      (TaskHandle taskHandle, const char lines[], int32 attribute);


/** Task Configuration/Control
 **/


%rename(LoadTask) DAQmxLoadTask;
int32 __CFUNC     DAQmxLoadTask            (const char taskName[], TaskHandle *OUTPUT);
%rename(CreateTask) DAQmxCreateTask;
int32 __CFUNC     DAQmxCreateTask          (const char taskName[], TaskHandle *OUTPUT);
// Channel Names must be valid channels already available in MAX. They are not created.
%rename(AddGlobalChansToTask) DAQmxAddGlobalChansToTask;
int32 __CFUNC     DAQmxAddGlobalChansToTask(TaskHandle taskHandle, const char channelNames[]);

%rename(StartTask) DAQmxStartTask;
int32 __CFUNC     DAQmxStartTask           (TaskHandle taskHandle);
%rename(StopTask) DAQmxStopTask;
int32 __CFUNC     DAQmxStopTask            (TaskHandle taskHandle);

%rename(ClearTask) DAQmxClearTask;
int32 __CFUNC     DAQmxClearTask           (TaskHandle taskHandle);

%rename(WaitUntilTaskDone) DAQmxWaitUntilTaskDone;
int32 __CFUNC     DAQmxWaitUntilTaskDone   (TaskHandle taskHandle, float64 timeToWait);
%rename(IsTaskDone) DAQmxIsTaskDone;
int32 __CFUNC     DAQmxIsTaskDone          (TaskHandle taskHandle, bool32 *isTaskDone);

%rename(TaskControl) DAQmxTaskControl;
int32 __CFUNC     DAQmxTaskControl         (TaskHandle taskHandle, int32 action);

%rename(GetNthTaskChannel) DAQmxGetNthTaskChannel;
int32 __CFUNC     DAQmxGetNthTaskChannel   (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

%rename(GetNthTaskDevice) DAQmxGetNthTaskDevice;
int32 __CFUNC     DAQmxGetNthTaskDevice    (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

%rename(GetTaskAttribute) DAQmxGetTaskAttribute;
int32 __CFUNC_C   DAQmxGetTaskAttribute    (TaskHandle taskHandle, int32 attribute, void *value, ...);

%rename(EveryNSamplesEventCallbackPtr) DAQmxEveryNSamplesEventCallbackPtr;
typedef int32 (CVICALLBACK *DAQmxEveryNSamplesEventCallbackPtr)(TaskHandle taskHandle, int32 everyNsamplesEventType, uInt32 nSamples, void *callbackData);
%rename(DoneEventCallbackPtr) DAQmxDoneEventCallbackPtr;
typedef int32 (CVICALLBACK *DAQmxDoneEventCallbackPtr)(TaskHandle taskHandle, int32 status, void *callbackData);
%rename(SignalEventCallbackPtr) DAQmxSignalEventCallbackPtr;
typedef int32 (CVICALLBACK *DAQmxSignalEventCallbackPtr)(TaskHandle taskHandle, int32 signalID, void *callbackData);

%rename(RegisterEveryNSamplesEvent) DAQmxRegisterEveryNSamplesEvent;
int32 __CFUNC     DAQmxRegisterEveryNSamplesEvent (TaskHandle task, int32 everyNsamplesEventType, uInt32 nSamples, uInt32 options, DAQmxEveryNSamplesEventCallbackPtr callbackFunction, void *callbackData);
%rename(RegisterDoneEvent) DAQmxRegisterDoneEvent;
int32 __CFUNC     DAQmxRegisterDoneEvent          (TaskHandle task, uInt32 options, DAQmxDoneEventCallbackPtr callbackFunction, void *callbackData);
%rename(RegisterSignalEvent) DAQmxRegisterSignalEvent;
int32 __CFUNC     DAQmxRegisterSignalEvent        (TaskHandle task, int32 signalID, uInt32 options, DAQmxSignalEventCallbackPtr callbackFunction, void *callbackData);

/** Switch Functions
 **/


%rename(SwitchCreateScanList) DAQmxSwitchCreateScanList;
int32 __CFUNC     DAQmxSwitchCreateScanList      (const char scanList[], TaskHandle *OUTPUT);

%rename(SwitchConnect) DAQmxSwitchConnect;
int32 __CFUNC     DAQmxSwitchConnect             (const char switchChannel1[], const char switchChannel2[], bool32 waitForSettling);
%rename(SwitchConnectMulti) DAQmxSwitchConnectMulti;
int32 __CFUNC     DAQmxSwitchConnectMulti        (const char connectionList[], bool32 waitForSettling);
%rename(SwitchDisconnect) DAQmxSwitchDisconnect;
int32 __CFUNC     DAQmxSwitchDisconnect          (const char switchChannel1[], const char switchChannel2[], bool32 waitForSettling);
%rename(SwitchDisconnectMulti) DAQmxSwitchDisconnectMulti;
int32 __CFUNC     DAQmxSwitchDisconnectMulti     (const char connectionList[], bool32 waitForSettling);
%rename(SwitchDisconnectAll) DAQmxSwitchDisconnectAll;
int32 __CFUNC     DAQmxSwitchDisconnectAll       (const char deviceName[], bool32 waitForSettling);

// Switch Topologies
%rename(Val_Switch_Topology_1127_1_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_1127_1_Wire_64x1_Mux;
%feature("docstring", " 1127/1-Wire 64x1 Mux") Val_Switch_Topology_1127_1_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_1127_1_Wire_64x1_Mux            "1127/1-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_1127_2_Wire_32x1_Mux) DAQmx_Val_Switch_Topology_1127_2_Wire_32x1_Mux;
%feature("docstring", " 1127/2-Wire 32x1 Mux") Val_Switch_Topology_1127_2_Wire_32x1_Mux;
#define DAQmx_Val_Switch_Topology_1127_2_Wire_32x1_Mux            "1127/2-Wire 32x1 Mux"              
%rename(Val_Switch_Topology_1127_2_Wire_4x8_Matrix) DAQmx_Val_Switch_Topology_1127_2_Wire_4x8_Matrix;
%feature("docstring", " 1127/2-Wire 4x8 Matrix") Val_Switch_Topology_1127_2_Wire_4x8_Matrix;
#define DAQmx_Val_Switch_Topology_1127_2_Wire_4x8_Matrix          "1127/2-Wire 4x8 Matrix"            
%rename(Val_Switch_Topology_1127_4_Wire_16x1_Mux) DAQmx_Val_Switch_Topology_1127_4_Wire_16x1_Mux;
%feature("docstring", " 1127/4-Wire 16x1 Mux") Val_Switch_Topology_1127_4_Wire_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1127_4_Wire_16x1_Mux            "1127/4-Wire 16x1 Mux"              
%rename(Val_Switch_Topology_1127_Independent) DAQmx_Val_Switch_Topology_1127_Independent;
%feature("docstring", " 1127/Independent") Val_Switch_Topology_1127_Independent;
#define DAQmx_Val_Switch_Topology_1127_Independent                "1127/Independent"                  
%rename(Val_Switch_Topology_1128_1_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_1128_1_Wire_64x1_Mux;
%feature("docstring", " 1128/1-Wire 64x1 Mux") Val_Switch_Topology_1128_1_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_1128_1_Wire_64x1_Mux            "1128/1-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_1128_2_Wire_32x1_Mux) DAQmx_Val_Switch_Topology_1128_2_Wire_32x1_Mux;
%feature("docstring", " 1128/2-Wire 32x1 Mux") Val_Switch_Topology_1128_2_Wire_32x1_Mux;
#define DAQmx_Val_Switch_Topology_1128_2_Wire_32x1_Mux            "1128/2-Wire 32x1 Mux"              
%rename(Val_Switch_Topology_1128_2_Wire_4x8_Matrix) DAQmx_Val_Switch_Topology_1128_2_Wire_4x8_Matrix;
%feature("docstring", " 1128/2-Wire 4x8 Matrix") Val_Switch_Topology_1128_2_Wire_4x8_Matrix;
#define DAQmx_Val_Switch_Topology_1128_2_Wire_4x8_Matrix          "1128/2-Wire 4x8 Matrix"            
%rename(Val_Switch_Topology_1128_4_Wire_16x1_Mux) DAQmx_Val_Switch_Topology_1128_4_Wire_16x1_Mux;
%feature("docstring", " 1128/4-Wire 16x1 Mux") Val_Switch_Topology_1128_4_Wire_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1128_4_Wire_16x1_Mux            "1128/4-Wire 16x1 Mux"              
%rename(Val_Switch_Topology_1128_Independent) DAQmx_Val_Switch_Topology_1128_Independent;
%feature("docstring", " 1128/Independent") Val_Switch_Topology_1128_Independent;
#define DAQmx_Val_Switch_Topology_1128_Independent                "1128/Independent"                  
%rename(Val_Switch_Topology_1129_2_Wire_16x16_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_16x16_Matrix;
%feature("docstring", " 1129/2-Wire 16x16 Matrix") Val_Switch_Topology_1129_2_Wire_16x16_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_16x16_Matrix        "1129/2-Wire 16x16 Matrix"          
%rename(Val_Switch_Topology_1129_2_Wire_8x32_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_8x32_Matrix;
%feature("docstring", " 1129/2-Wire 8x32 Matrix") Val_Switch_Topology_1129_2_Wire_8x32_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_8x32_Matrix         "1129/2-Wire 8x32 Matrix"           
%rename(Val_Switch_Topology_1129_2_Wire_4x64_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_4x64_Matrix;
%feature("docstring", " 1129/2-Wire 4x64 Matrix") Val_Switch_Topology_1129_2_Wire_4x64_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_4x64_Matrix         "1129/2-Wire 4x64 Matrix"           
%rename(Val_Switch_Topology_1129_2_Wire_Dual_8x16_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_Dual_8x16_Matrix;
%feature("docstring", " 1129/2-Wire Dual 8x16 Matrix") Val_Switch_Topology_1129_2_Wire_Dual_8x16_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_Dual_8x16_Matrix    "1129/2-Wire Dual 8x16 Matrix"      
%rename(Val_Switch_Topology_1129_2_Wire_Dual_4x32_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_Dual_4x32_Matrix;
%feature("docstring", " 1129/2-Wire Dual 4x32 Matrix") Val_Switch_Topology_1129_2_Wire_Dual_4x32_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_Dual_4x32_Matrix    "1129/2-Wire Dual 4x32 Matrix"      
%rename(Val_Switch_Topology_1129_2_Wire_Quad_4x16_Matrix) DAQmx_Val_Switch_Topology_1129_2_Wire_Quad_4x16_Matrix;
%feature("docstring", " 1129/2-Wire Quad 4x16 Matrix") Val_Switch_Topology_1129_2_Wire_Quad_4x16_Matrix;
#define DAQmx_Val_Switch_Topology_1129_2_Wire_Quad_4x16_Matrix    "1129/2-Wire Quad 4x16 Matrix"      
%rename(Val_Switch_Topology_1130_1_Wire_256x1_Mux) DAQmx_Val_Switch_Topology_1130_1_Wire_256x1_Mux;
%feature("docstring", " 1130/1-Wire 256x1 Mux") Val_Switch_Topology_1130_1_Wire_256x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_256x1_Mux           "1130/1-Wire 256x1 Mux"             
%rename(Val_Switch_Topology_1130_1_Wire_Dual_128x1_Mux) DAQmx_Val_Switch_Topology_1130_1_Wire_Dual_128x1_Mux;
%feature("docstring", " 1130/1-Wire Dual 128x1 Mux") Val_Switch_Topology_1130_1_Wire_Dual_128x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_Dual_128x1_Mux      "1130/1-Wire Dual 128x1 Mux"        
%rename(Val_Switch_Topology_1130_2_Wire_128x1_Mux) DAQmx_Val_Switch_Topology_1130_2_Wire_128x1_Mux;
%feature("docstring", " 1130/2-Wire 128x1 Mux") Val_Switch_Topology_1130_2_Wire_128x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_2_Wire_128x1_Mux           "1130/2-Wire 128x1 Mux"             
%rename(Val_Switch_Topology_1130_4_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_1130_4_Wire_64x1_Mux;
%feature("docstring", " 1130/4-Wire 64x1 Mux") Val_Switch_Topology_1130_4_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_4_Wire_64x1_Mux            "1130/4-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_1130_1_Wire_4x64_Matrix) DAQmx_Val_Switch_Topology_1130_1_Wire_4x64_Matrix;
%feature("docstring", " 1130/1-Wire 4x64 Matrix") Val_Switch_Topology_1130_1_Wire_4x64_Matrix;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_4x64_Matrix         "1130/1-Wire 4x64 Matrix"           
%rename(Val_Switch_Topology_1130_1_Wire_8x32_Matrix) DAQmx_Val_Switch_Topology_1130_1_Wire_8x32_Matrix;
%feature("docstring", " 1130/1-Wire 8x32 Matrix") Val_Switch_Topology_1130_1_Wire_8x32_Matrix;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_8x32_Matrix         "1130/1-Wire 8x32 Matrix"           
%rename(Val_Switch_Topology_1130_1_Wire_Octal_32x1_Mux) DAQmx_Val_Switch_Topology_1130_1_Wire_Octal_32x1_Mux;
%feature("docstring", " 1130/1-Wire Octal 32x1 Mux") Val_Switch_Topology_1130_1_Wire_Octal_32x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_Octal_32x1_Mux      "1130/1-Wire Octal 32x1 Mux"        
%rename(Val_Switch_Topology_1130_1_Wire_Quad_64x1_Mux) DAQmx_Val_Switch_Topology_1130_1_Wire_Quad_64x1_Mux;
%feature("docstring", " 1130/1-Wire Quad 64x1 Mux") Val_Switch_Topology_1130_1_Wire_Quad_64x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_Quad_64x1_Mux       "1130/1-Wire Quad 64x1 Mux"         
%rename(Val_Switch_Topology_1130_1_Wire_Sixteen_16x1_Mux) DAQmx_Val_Switch_Topology_1130_1_Wire_Sixteen_16x1_Mux;
%feature("docstring", " 1130/1-Wire Sixteen 16x1 Mux") Val_Switch_Topology_1130_1_Wire_Sixteen_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_1_Wire_Sixteen_16x1_Mux    "1130/1-Wire Sixteen 16x1 Mux"      
%rename(Val_Switch_Topology_1130_2_Wire_4x32_Matrix) DAQmx_Val_Switch_Topology_1130_2_Wire_4x32_Matrix;
%feature("docstring", " 1130/2-Wire 4x32 Matrix") Val_Switch_Topology_1130_2_Wire_4x32_Matrix;
#define DAQmx_Val_Switch_Topology_1130_2_Wire_4x32_Matrix         "1130/2-Wire 4x32 Matrix"           
%rename(Val_Switch_Topology_1130_2_Wire_Octal_16x1_Mux) DAQmx_Val_Switch_Topology_1130_2_Wire_Octal_16x1_Mux;
%feature("docstring", " 1130/2-Wire Octal 16x1 Mux") Val_Switch_Topology_1130_2_Wire_Octal_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_2_Wire_Octal_16x1_Mux      "1130/2-Wire Octal 16x1 Mux"        
%rename(Val_Switch_Topology_1130_2_Wire_Quad_32x1_Mux) DAQmx_Val_Switch_Topology_1130_2_Wire_Quad_32x1_Mux;
%feature("docstring", " 1130/2-Wire Quad 32x1 Mux") Val_Switch_Topology_1130_2_Wire_Quad_32x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_2_Wire_Quad_32x1_Mux       "1130/2-Wire Quad 32x1 Mux"         
%rename(Val_Switch_Topology_1130_4_Wire_Quad_16x1_Mux) DAQmx_Val_Switch_Topology_1130_4_Wire_Quad_16x1_Mux;
%feature("docstring", " 1130/4-Wire Quad 16x1 Mux") Val_Switch_Topology_1130_4_Wire_Quad_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1130_4_Wire_Quad_16x1_Mux       "1130/4-Wire Quad 16x1 Mux"         
%rename(Val_Switch_Topology_1130_Independent) DAQmx_Val_Switch_Topology_1130_Independent;
%feature("docstring", " 1130/Independent") Val_Switch_Topology_1130_Independent;
#define DAQmx_Val_Switch_Topology_1130_Independent                "1130/Independent"                  
%rename(Val_Switch_Topology_1160_16_SPDT) DAQmx_Val_Switch_Topology_1160_16_SPDT;
%feature("docstring", " 1160/16-SPDT") Val_Switch_Topology_1160_16_SPDT;
#define DAQmx_Val_Switch_Topology_1160_16_SPDT                    "1160/16-SPDT"                      
%rename(Val_Switch_Topology_1161_8_SPDT) DAQmx_Val_Switch_Topology_1161_8_SPDT;
%feature("docstring", " 1161/8-SPDT") Val_Switch_Topology_1161_8_SPDT;
#define DAQmx_Val_Switch_Topology_1161_8_SPDT                     "1161/8-SPDT"                       
%rename(Val_Switch_Topology_1163R_Octal_4x1_Mux) DAQmx_Val_Switch_Topology_1163R_Octal_4x1_Mux;
%feature("docstring", " 1163R/Octal 4x1 Mux") Val_Switch_Topology_1163R_Octal_4x1_Mux;
#define DAQmx_Val_Switch_Topology_1163R_Octal_4x1_Mux             "1163R/Octal 4x1 Mux"               
%rename(Val_Switch_Topology_1166_32_SPDT) DAQmx_Val_Switch_Topology_1166_32_SPDT;
%feature("docstring", " 1166/32-SPDT") Val_Switch_Topology_1166_32_SPDT;
#define DAQmx_Val_Switch_Topology_1166_32_SPDT                    "1166/32-SPDT"                      
%rename(Val_Switch_Topology_1166_16_DPDT) DAQmx_Val_Switch_Topology_1166_16_DPDT;
%feature("docstring", " 1166/16-DPDT") Val_Switch_Topology_1166_16_DPDT;
#define DAQmx_Val_Switch_Topology_1166_16_DPDT                    "1166/16-DPDT"                      
%rename(Val_Switch_Topology_1167_Independent) DAQmx_Val_Switch_Topology_1167_Independent;
%feature("docstring", " 1167/Independent") Val_Switch_Topology_1167_Independent;
#define DAQmx_Val_Switch_Topology_1167_Independent                "1167/Independent"                  
%rename(Val_Switch_Topology_1169_100_SPST) DAQmx_Val_Switch_Topology_1169_100_SPST;
%feature("docstring", " 1169/100-SPST") Val_Switch_Topology_1169_100_SPST;
#define DAQmx_Val_Switch_Topology_1169_100_SPST                   "1169/100-SPST"                     
%rename(Val_Switch_Topology_1169_50_DPST) DAQmx_Val_Switch_Topology_1169_50_DPST;
%feature("docstring", " 1169/50-DPST") Val_Switch_Topology_1169_50_DPST;
#define DAQmx_Val_Switch_Topology_1169_50_DPST                    "1169/50-DPST"                      
%rename(Val_Switch_Topology_1175_1_Wire_196x1_Mux) DAQmx_Val_Switch_Topology_1175_1_Wire_196x1_Mux;
%feature("docstring", " 1175/1-Wire 196x1 Mux") Val_Switch_Topology_1175_1_Wire_196x1_Mux;
#define DAQmx_Val_Switch_Topology_1175_1_Wire_196x1_Mux           "1175/1-Wire 196x1 Mux"             
%rename(Val_Switch_Topology_1175_2_Wire_98x1_Mux) DAQmx_Val_Switch_Topology_1175_2_Wire_98x1_Mux;
%feature("docstring", " 1175/2-Wire 98x1 Mux") Val_Switch_Topology_1175_2_Wire_98x1_Mux;
#define DAQmx_Val_Switch_Topology_1175_2_Wire_98x1_Mux            "1175/2-Wire 98x1 Mux"              
%rename(Val_Switch_Topology_1175_2_Wire_95x1_Mux) DAQmx_Val_Switch_Topology_1175_2_Wire_95x1_Mux;
%feature("docstring", " 1175/2-Wire 95x1 Mux") Val_Switch_Topology_1175_2_Wire_95x1_Mux;
#define DAQmx_Val_Switch_Topology_1175_2_Wire_95x1_Mux            "1175/2-Wire 95x1 Mux"              
%rename(Val_Switch_Topology_1190_Quad_4x1_Mux) DAQmx_Val_Switch_Topology_1190_Quad_4x1_Mux;
%feature("docstring", " 1190/Quad 4x1 Mux") Val_Switch_Topology_1190_Quad_4x1_Mux;
#define DAQmx_Val_Switch_Topology_1190_Quad_4x1_Mux               "1190/Quad 4x1 Mux"                 
%rename(Val_Switch_Topology_1191_Quad_4x1_Mux) DAQmx_Val_Switch_Topology_1191_Quad_4x1_Mux;
%feature("docstring", " 1191/Quad 4x1 Mux") Val_Switch_Topology_1191_Quad_4x1_Mux;
#define DAQmx_Val_Switch_Topology_1191_Quad_4x1_Mux               "1191/Quad 4x1 Mux"                 
%rename(Val_Switch_Topology_1192_8_SPDT) DAQmx_Val_Switch_Topology_1192_8_SPDT;
%feature("docstring", " 1192/8-SPDT") Val_Switch_Topology_1192_8_SPDT;
#define DAQmx_Val_Switch_Topology_1192_8_SPDT                     "1192/8-SPDT"                       
%rename(Val_Switch_Topology_1193_32x1_Mux) DAQmx_Val_Switch_Topology_1193_32x1_Mux;
%feature("docstring", " 1193/32x1 Mux") Val_Switch_Topology_1193_32x1_Mux;
#define DAQmx_Val_Switch_Topology_1193_32x1_Mux                   "1193/32x1 Mux"                     
%rename(Val_Switch_Topology_1193_Dual_16x1_Mux) DAQmx_Val_Switch_Topology_1193_Dual_16x1_Mux;
%feature("docstring", " 1193/Dual 16x1 Mux") Val_Switch_Topology_1193_Dual_16x1_Mux;
#define DAQmx_Val_Switch_Topology_1193_Dual_16x1_Mux              "1193/Dual 16x1 Mux"                
%rename(Val_Switch_Topology_1193_Quad_8x1_Mux) DAQmx_Val_Switch_Topology_1193_Quad_8x1_Mux;
%feature("docstring", " 1193/Quad 8x1 Mux") Val_Switch_Topology_1193_Quad_8x1_Mux;
#define DAQmx_Val_Switch_Topology_1193_Quad_8x1_Mux               "1193/Quad 8x1 Mux"                 
%rename(Val_Switch_Topology_1193_16x1_Terminated_Mux) DAQmx_Val_Switch_Topology_1193_16x1_Terminated_Mux;
%feature("docstring", " 1193/16x1 Terminated Mux") Val_Switch_Topology_1193_16x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_1193_16x1_Terminated_Mux        "1193/16x1 Terminated Mux"          
%rename(Val_Switch_Topology_1193_Dual_8x1_Terminated_Mux) DAQmx_Val_Switch_Topology_1193_Dual_8x1_Terminated_Mux;
%feature("docstring", " 1193/Dual 8x1 Terminated Mux") Val_Switch_Topology_1193_Dual_8x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_1193_Dual_8x1_Terminated_Mux    "1193/Dual 8x1 Terminated Mux"      
%rename(Val_Switch_Topology_1193_Quad_4x1_Terminated_Mux) DAQmx_Val_Switch_Topology_1193_Quad_4x1_Terminated_Mux;
%feature("docstring", " 1193/Quad 4x1 Terminated Mux") Val_Switch_Topology_1193_Quad_4x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_1193_Quad_4x1_Terminated_Mux    "1193/Quad 4x1 Terminated Mux"      
%rename(Val_Switch_Topology_1193_Independent) DAQmx_Val_Switch_Topology_1193_Independent;
%feature("docstring", " 1193/Independent") Val_Switch_Topology_1193_Independent;
#define DAQmx_Val_Switch_Topology_1193_Independent                "1193/Independent"                  
%rename(Val_Switch_Topology_1194_Quad_4x1_Mux) DAQmx_Val_Switch_Topology_1194_Quad_4x1_Mux;
%feature("docstring", " 1194/Quad 4x1 Mux") Val_Switch_Topology_1194_Quad_4x1_Mux;
#define DAQmx_Val_Switch_Topology_1194_Quad_4x1_Mux               "1194/Quad 4x1 Mux"                 
%rename(Val_Switch_Topology_1195_Quad_4x1_Mux) DAQmx_Val_Switch_Topology_1195_Quad_4x1_Mux;
%feature("docstring", " 1195/Quad 4x1 Mux") Val_Switch_Topology_1195_Quad_4x1_Mux;
#define DAQmx_Val_Switch_Topology_1195_Quad_4x1_Mux               "1195/Quad 4x1 Mux"                 
%rename(Val_Switch_Topology_2501_1_Wire_48x1_Mux) DAQmx_Val_Switch_Topology_2501_1_Wire_48x1_Mux;
%feature("docstring", " 2501/1-Wire 48x1 Mux") Val_Switch_Topology_2501_1_Wire_48x1_Mux;
#define DAQmx_Val_Switch_Topology_2501_1_Wire_48x1_Mux            "2501/1-Wire 48x1 Mux"              
%rename(Val_Switch_Topology_2501_1_Wire_48x1_Amplified_Mux) DAQmx_Val_Switch_Topology_2501_1_Wire_48x1_Amplified_Mux;
%feature("docstring", " 2501/1-Wire 48x1 Amplified Mux") Val_Switch_Topology_2501_1_Wire_48x1_Amplified_Mux;
#define DAQmx_Val_Switch_Topology_2501_1_Wire_48x1_Amplified_Mux  "2501/1-Wire 48x1 Amplified Mux"    
%rename(Val_Switch_Topology_2501_2_Wire_24x1_Mux) DAQmx_Val_Switch_Topology_2501_2_Wire_24x1_Mux;
%feature("docstring", " 2501/2-Wire 24x1 Mux") Val_Switch_Topology_2501_2_Wire_24x1_Mux;
#define DAQmx_Val_Switch_Topology_2501_2_Wire_24x1_Mux            "2501/2-Wire 24x1 Mux"              
%rename(Val_Switch_Topology_2501_2_Wire_24x1_Amplified_Mux) DAQmx_Val_Switch_Topology_2501_2_Wire_24x1_Amplified_Mux;
%feature("docstring", " 2501/2-Wire 24x1 Amplified Mux") Val_Switch_Topology_2501_2_Wire_24x1_Amplified_Mux;
#define DAQmx_Val_Switch_Topology_2501_2_Wire_24x1_Amplified_Mux  "2501/2-Wire 24x1 Amplified Mux"    
%rename(Val_Switch_Topology_2501_2_Wire_Dual_12x1_Mux) DAQmx_Val_Switch_Topology_2501_2_Wire_Dual_12x1_Mux;
%feature("docstring", " 2501/2-Wire Dual 12x1 Mux") Val_Switch_Topology_2501_2_Wire_Dual_12x1_Mux;
#define DAQmx_Val_Switch_Topology_2501_2_Wire_Dual_12x1_Mux       "2501/2-Wire Dual 12x1 Mux"         
%rename(Val_Switch_Topology_2501_2_Wire_Quad_6x1_Mux) DAQmx_Val_Switch_Topology_2501_2_Wire_Quad_6x1_Mux;
%feature("docstring", " 2501/2-Wire Quad 6x1 Mux") Val_Switch_Topology_2501_2_Wire_Quad_6x1_Mux;
#define DAQmx_Val_Switch_Topology_2501_2_Wire_Quad_6x1_Mux        "2501/2-Wire Quad 6x1 Mux"          
%rename(Val_Switch_Topology_2501_2_Wire_4x6_Matrix) DAQmx_Val_Switch_Topology_2501_2_Wire_4x6_Matrix;
%feature("docstring", " 2501/2-Wire 4x6 Matrix") Val_Switch_Topology_2501_2_Wire_4x6_Matrix;
#define DAQmx_Val_Switch_Topology_2501_2_Wire_4x6_Matrix          "2501/2-Wire 4x6 Matrix"            
%rename(Val_Switch_Topology_2501_4_Wire_12x1_Mux) DAQmx_Val_Switch_Topology_2501_4_Wire_12x1_Mux;
%feature("docstring", " 2501/4-Wire 12x1 Mux") Val_Switch_Topology_2501_4_Wire_12x1_Mux;
#define DAQmx_Val_Switch_Topology_2501_4_Wire_12x1_Mux            "2501/4-Wire 12x1 Mux"              
%rename(Val_Switch_Topology_2503_1_Wire_48x1_Mux) DAQmx_Val_Switch_Topology_2503_1_Wire_48x1_Mux;
%feature("docstring", " 2503/1-Wire 48x1 Mux") Val_Switch_Topology_2503_1_Wire_48x1_Mux;
#define DAQmx_Val_Switch_Topology_2503_1_Wire_48x1_Mux            "2503/1-Wire 48x1 Mux"              
%rename(Val_Switch_Topology_2503_2_Wire_24x1_Mux) DAQmx_Val_Switch_Topology_2503_2_Wire_24x1_Mux;
%feature("docstring", " 2503/2-Wire 24x1 Mux") Val_Switch_Topology_2503_2_Wire_24x1_Mux;
#define DAQmx_Val_Switch_Topology_2503_2_Wire_24x1_Mux            "2503/2-Wire 24x1 Mux"              
%rename(Val_Switch_Topology_2503_2_Wire_Dual_12x1_Mux) DAQmx_Val_Switch_Topology_2503_2_Wire_Dual_12x1_Mux;
%feature("docstring", " 2503/2-Wire Dual 12x1 Mux") Val_Switch_Topology_2503_2_Wire_Dual_12x1_Mux;
#define DAQmx_Val_Switch_Topology_2503_2_Wire_Dual_12x1_Mux       "2503/2-Wire Dual 12x1 Mux"         
%rename(Val_Switch_Topology_2503_2_Wire_Quad_6x1_Mux) DAQmx_Val_Switch_Topology_2503_2_Wire_Quad_6x1_Mux;
%feature("docstring", " 2503/2-Wire Quad 6x1 Mux") Val_Switch_Topology_2503_2_Wire_Quad_6x1_Mux;
#define DAQmx_Val_Switch_Topology_2503_2_Wire_Quad_6x1_Mux        "2503/2-Wire Quad 6x1 Mux"          
%rename(Val_Switch_Topology_2503_2_Wire_4x6_Matrix) DAQmx_Val_Switch_Topology_2503_2_Wire_4x6_Matrix;
%feature("docstring", " 2503/2-Wire 4x6 Matrix") Val_Switch_Topology_2503_2_Wire_4x6_Matrix;
#define DAQmx_Val_Switch_Topology_2503_2_Wire_4x6_Matrix          "2503/2-Wire 4x6 Matrix"            
%rename(Val_Switch_Topology_2503_4_Wire_12x1_Mux) DAQmx_Val_Switch_Topology_2503_4_Wire_12x1_Mux;
%feature("docstring", " 2503/4-Wire 12x1 Mux") Val_Switch_Topology_2503_4_Wire_12x1_Mux;
#define DAQmx_Val_Switch_Topology_2503_4_Wire_12x1_Mux            "2503/4-Wire 12x1 Mux"              
%rename(Val_Switch_Topology_2527_1_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_2527_1_Wire_64x1_Mux;
%feature("docstring", " 2527/1-Wire 64x1 Mux") Val_Switch_Topology_2527_1_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_2527_1_Wire_64x1_Mux            "2527/1-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_2527_1_Wire_Dual_32x1_Mux) DAQmx_Val_Switch_Topology_2527_1_Wire_Dual_32x1_Mux;
%feature("docstring", " 2527/1-Wire Dual 32x1 Mux") Val_Switch_Topology_2527_1_Wire_Dual_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2527_1_Wire_Dual_32x1_Mux       "2527/1-Wire Dual 32x1 Mux"         
%rename(Val_Switch_Topology_2527_2_Wire_32x1_Mux) DAQmx_Val_Switch_Topology_2527_2_Wire_32x1_Mux;
%feature("docstring", " 2527/2-Wire 32x1 Mux") Val_Switch_Topology_2527_2_Wire_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2527_2_Wire_32x1_Mux            "2527/2-Wire 32x1 Mux"              
%rename(Val_Switch_Topology_2527_2_Wire_Dual_16x1_Mux) DAQmx_Val_Switch_Topology_2527_2_Wire_Dual_16x1_Mux;
%feature("docstring", " 2527/2-Wire Dual 16x1 Mux") Val_Switch_Topology_2527_2_Wire_Dual_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2527_2_Wire_Dual_16x1_Mux       "2527/2-Wire Dual 16x1 Mux"         
%rename(Val_Switch_Topology_2527_4_Wire_16x1_Mux) DAQmx_Val_Switch_Topology_2527_4_Wire_16x1_Mux;
%feature("docstring", " 2527/4-Wire 16x1 Mux") Val_Switch_Topology_2527_4_Wire_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2527_4_Wire_16x1_Mux            "2527/4-Wire 16x1 Mux"              
%rename(Val_Switch_Topology_2527_Independent) DAQmx_Val_Switch_Topology_2527_Independent;
%feature("docstring", " 2527/Independent") Val_Switch_Topology_2527_Independent;
#define DAQmx_Val_Switch_Topology_2527_Independent                "2527/Independent"                  
%rename(Val_Switch_Topology_2529_2_Wire_8x16_Matrix) DAQmx_Val_Switch_Topology_2529_2_Wire_8x16_Matrix;
%feature("docstring", " 2529/2-Wire 8x16 Matrix") Val_Switch_Topology_2529_2_Wire_8x16_Matrix;
#define DAQmx_Val_Switch_Topology_2529_2_Wire_8x16_Matrix         "2529/2-Wire 8x16 Matrix"           
%rename(Val_Switch_Topology_2529_2_Wire_4x32_Matrix) DAQmx_Val_Switch_Topology_2529_2_Wire_4x32_Matrix;
%feature("docstring", " 2529/2-Wire 4x32 Matrix") Val_Switch_Topology_2529_2_Wire_4x32_Matrix;
#define DAQmx_Val_Switch_Topology_2529_2_Wire_4x32_Matrix         "2529/2-Wire 4x32 Matrix"           
%rename(Val_Switch_Topology_2529_2_Wire_Dual_4x16_Matrix) DAQmx_Val_Switch_Topology_2529_2_Wire_Dual_4x16_Matrix;
%feature("docstring", " 2529/2-Wire Dual 4x16 Matrix") Val_Switch_Topology_2529_2_Wire_Dual_4x16_Matrix;
#define DAQmx_Val_Switch_Topology_2529_2_Wire_Dual_4x16_Matrix    "2529/2-Wire Dual 4x16 Matrix"      
%rename(Val_Switch_Topology_2530_1_Wire_128x1_Mux) DAQmx_Val_Switch_Topology_2530_1_Wire_128x1_Mux;
%feature("docstring", " 2530/1-Wire 128x1 Mux") Val_Switch_Topology_2530_1_Wire_128x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_128x1_Mux           "2530/1-Wire 128x1 Mux"             
%rename(Val_Switch_Topology_2530_1_Wire_Dual_64x1_Mux) DAQmx_Val_Switch_Topology_2530_1_Wire_Dual_64x1_Mux;
%feature("docstring", " 2530/1-Wire Dual 64x1 Mux") Val_Switch_Topology_2530_1_Wire_Dual_64x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_Dual_64x1_Mux       "2530/1-Wire Dual 64x1 Mux"         
%rename(Val_Switch_Topology_2530_2_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_2530_2_Wire_64x1_Mux;
%feature("docstring", " 2530/2-Wire 64x1 Mux") Val_Switch_Topology_2530_2_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_2_Wire_64x1_Mux            "2530/2-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_2530_4_Wire_32x1_Mux) DAQmx_Val_Switch_Topology_2530_4_Wire_32x1_Mux;
%feature("docstring", " 2530/4-Wire 32x1 Mux") Val_Switch_Topology_2530_4_Wire_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_4_Wire_32x1_Mux            "2530/4-Wire 32x1 Mux"              
%rename(Val_Switch_Topology_2530_1_Wire_4x32_Matrix) DAQmx_Val_Switch_Topology_2530_1_Wire_4x32_Matrix;
%feature("docstring", " 2530/1-Wire 4x32 Matrix") Val_Switch_Topology_2530_1_Wire_4x32_Matrix;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_4x32_Matrix         "2530/1-Wire 4x32 Matrix"           
%rename(Val_Switch_Topology_2530_1_Wire_8x16_Matrix) DAQmx_Val_Switch_Topology_2530_1_Wire_8x16_Matrix;
%feature("docstring", " 2530/1-Wire 8x16 Matrix") Val_Switch_Topology_2530_1_Wire_8x16_Matrix;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_8x16_Matrix         "2530/1-Wire 8x16 Matrix"           
%rename(Val_Switch_Topology_2530_1_Wire_Octal_16x1_Mux) DAQmx_Val_Switch_Topology_2530_1_Wire_Octal_16x1_Mux;
%feature("docstring", " 2530/1-Wire Octal 16x1 Mux") Val_Switch_Topology_2530_1_Wire_Octal_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_Octal_16x1_Mux      "2530/1-Wire Octal 16x1 Mux"        
%rename(Val_Switch_Topology_2530_1_Wire_Quad_32x1_Mux) DAQmx_Val_Switch_Topology_2530_1_Wire_Quad_32x1_Mux;
%feature("docstring", " 2530/1-Wire Quad 32x1 Mux") Val_Switch_Topology_2530_1_Wire_Quad_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_1_Wire_Quad_32x1_Mux       "2530/1-Wire Quad 32x1 Mux"         
%rename(Val_Switch_Topology_2530_2_Wire_4x16_Matrix) DAQmx_Val_Switch_Topology_2530_2_Wire_4x16_Matrix;
%feature("docstring", " 2530/2-Wire 4x16 Matrix") Val_Switch_Topology_2530_2_Wire_4x16_Matrix;
#define DAQmx_Val_Switch_Topology_2530_2_Wire_4x16_Matrix         "2530/2-Wire 4x16 Matrix"           
%rename(Val_Switch_Topology_2530_2_Wire_Dual_32x1_Mux) DAQmx_Val_Switch_Topology_2530_2_Wire_Dual_32x1_Mux;
%feature("docstring", " 2530/2-Wire Dual 32x1 Mux") Val_Switch_Topology_2530_2_Wire_Dual_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_2_Wire_Dual_32x1_Mux       "2530/2-Wire Dual 32x1 Mux"         
%rename(Val_Switch_Topology_2530_2_Wire_Quad_16x1_Mux) DAQmx_Val_Switch_Topology_2530_2_Wire_Quad_16x1_Mux;
%feature("docstring", " 2530/2-Wire Quad 16x1 Mux") Val_Switch_Topology_2530_2_Wire_Quad_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_2_Wire_Quad_16x1_Mux       "2530/2-Wire Quad 16x1 Mux"         
%rename(Val_Switch_Topology_2530_4_Wire_Dual_16x1_Mux) DAQmx_Val_Switch_Topology_2530_4_Wire_Dual_16x1_Mux;
%feature("docstring", " 2530/4-Wire Dual 16x1 Mux") Val_Switch_Topology_2530_4_Wire_Dual_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2530_4_Wire_Dual_16x1_Mux       "2530/4-Wire Dual 16x1 Mux"         
%rename(Val_Switch_Topology_2530_Independent) DAQmx_Val_Switch_Topology_2530_Independent;
%feature("docstring", " 2530/Independent") Val_Switch_Topology_2530_Independent;
#define DAQmx_Val_Switch_Topology_2530_Independent                "2530/Independent"                  
%rename(Val_Switch_Topology_2532_1_Wire_16x32_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_16x32_Matrix;
%feature("docstring", " 2532/1-Wire 16x32 Matrix") Val_Switch_Topology_2532_1_Wire_16x32_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_16x32_Matrix        "2532/1-Wire 16x32 Matrix"          
%rename(Val_Switch_Topology_2532_1_Wire_4x128_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_4x128_Matrix;
%feature("docstring", " 2532/1-Wire 4x128 Matrix") Val_Switch_Topology_2532_1_Wire_4x128_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_4x128_Matrix        "2532/1-Wire 4x128 Matrix"          
%rename(Val_Switch_Topology_2532_1_Wire_8x64_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_8x64_Matrix;
%feature("docstring", " 2532/1-Wire 8x64 Matrix") Val_Switch_Topology_2532_1_Wire_8x64_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_8x64_Matrix         "2532/1-Wire 8x64 Matrix"           
%rename(Val_Switch_Topology_2532_1_Wire_Dual_16x16_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_16x16_Matrix;
%feature("docstring", " 2532/1-Wire Dual 16x16 Matrix") Val_Switch_Topology_2532_1_Wire_Dual_16x16_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_16x16_Matrix   "2532/1-Wire Dual 16x16 Matrix"     
%rename(Val_Switch_Topology_2532_1_Wire_Dual_4x64_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_4x64_Matrix;
%feature("docstring", " 2532/1-Wire Dual 4x64 Matrix") Val_Switch_Topology_2532_1_Wire_Dual_4x64_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_4x64_Matrix    "2532/1-Wire Dual 4x64 Matrix"      
%rename(Val_Switch_Topology_2532_1_Wire_Dual_8x32_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_8x32_Matrix;
%feature("docstring", " 2532/1-Wire Dual 8x32 Matrix") Val_Switch_Topology_2532_1_Wire_Dual_8x32_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_Dual_8x32_Matrix    "2532/1-Wire Dual 8x32 Matrix"      
%rename(Val_Switch_Topology_2532_1_Wire_Sixteen_2x16_Matrix) DAQmx_Val_Switch_Topology_2532_1_Wire_Sixteen_2x16_Matrix;
%feature("docstring", " 2532/1-Wire Sixteen 2x16 Matrix") Val_Switch_Topology_2532_1_Wire_Sixteen_2x16_Matrix;
#define DAQmx_Val_Switch_Topology_2532_1_Wire_Sixteen_2x16_Matrix "2532/1-Wire Sixteen 2x16 Matrix"   
%rename(Val_Switch_Topology_2532_2_Wire_16x16_Matrix) DAQmx_Val_Switch_Topology_2532_2_Wire_16x16_Matrix;
%feature("docstring", " 2532/2-Wire 16x16 Matrix") Val_Switch_Topology_2532_2_Wire_16x16_Matrix;
#define DAQmx_Val_Switch_Topology_2532_2_Wire_16x16_Matrix        "2532/2-Wire 16x16 Matrix"          
%rename(Val_Switch_Topology_2532_2_Wire_4x64_Matrix) DAQmx_Val_Switch_Topology_2532_2_Wire_4x64_Matrix;
%feature("docstring", " 2532/2-Wire 4x64 Matrix") Val_Switch_Topology_2532_2_Wire_4x64_Matrix;
#define DAQmx_Val_Switch_Topology_2532_2_Wire_4x64_Matrix         "2532/2-Wire 4x64 Matrix"           
%rename(Val_Switch_Topology_2532_2_Wire_8x32_Matrix) DAQmx_Val_Switch_Topology_2532_2_Wire_8x32_Matrix;
%feature("docstring", " 2532/2-Wire 8x32 Matrix") Val_Switch_Topology_2532_2_Wire_8x32_Matrix;
#define DAQmx_Val_Switch_Topology_2532_2_Wire_8x32_Matrix         "2532/2-Wire 8x32 Matrix"           
%rename(Val_Switch_Topology_2533_1_Wire_4x64_Matrix) DAQmx_Val_Switch_Topology_2533_1_Wire_4x64_Matrix;
%feature("docstring", " 2533/1-Wire 4x64 Matrix") Val_Switch_Topology_2533_1_Wire_4x64_Matrix;
#define DAQmx_Val_Switch_Topology_2533_1_Wire_4x64_Matrix         "2533/1-Wire 4x64 Matrix"           
%rename(Val_Switch_Topology_2534_1_Wire_8x32_Matrix) DAQmx_Val_Switch_Topology_2534_1_Wire_8x32_Matrix;
%feature("docstring", " 2534/1-Wire 8x32 Matrix") Val_Switch_Topology_2534_1_Wire_8x32_Matrix;
#define DAQmx_Val_Switch_Topology_2534_1_Wire_8x32_Matrix         "2534/1-Wire 8x32 Matrix"           
%rename(Val_Switch_Topology_2535_1_Wire_4x136_Matrix) DAQmx_Val_Switch_Topology_2535_1_Wire_4x136_Matrix;
%feature("docstring", " 2535/1-Wire 4x136 Matrix") Val_Switch_Topology_2535_1_Wire_4x136_Matrix;
#define DAQmx_Val_Switch_Topology_2535_1_Wire_4x136_Matrix        "2535/1-Wire 4x136 Matrix"          
%rename(Val_Switch_Topology_2536_1_Wire_8x68_Matrix) DAQmx_Val_Switch_Topology_2536_1_Wire_8x68_Matrix;
%feature("docstring", " 2536/1-Wire 8x68 Matrix") Val_Switch_Topology_2536_1_Wire_8x68_Matrix;
#define DAQmx_Val_Switch_Topology_2536_1_Wire_8x68_Matrix         "2536/1-Wire 8x68 Matrix"           
%rename(Val_Switch_Topology_2545_4x1_Terminated_Mux) DAQmx_Val_Switch_Topology_2545_4x1_Terminated_Mux;
%feature("docstring", " 2545/4x1 Terminated Mux") Val_Switch_Topology_2545_4x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_2545_4x1_Terminated_Mux         "2545/4x1 Terminated Mux"           
%rename(Val_Switch_Topology_2546_Dual_4x1_Mux) DAQmx_Val_Switch_Topology_2546_Dual_4x1_Mux;
%feature("docstring", " 2546/Dual 4x1 Mux") Val_Switch_Topology_2546_Dual_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2546_Dual_4x1_Mux               "2546/Dual 4x1 Mux"                 
%rename(Val_Switch_Topology_2547_8x1_Mux) DAQmx_Val_Switch_Topology_2547_8x1_Mux;
%feature("docstring", " 2547/8x1 Mux") Val_Switch_Topology_2547_8x1_Mux;
#define DAQmx_Val_Switch_Topology_2547_8x1_Mux                    "2547/8x1 Mux"                      
%rename(Val_Switch_Topology_2548_4_SPDT) DAQmx_Val_Switch_Topology_2548_4_SPDT;
%feature("docstring", " 2548/4-SPDT") Val_Switch_Topology_2548_4_SPDT;
#define DAQmx_Val_Switch_Topology_2548_4_SPDT                     "2548/4-SPDT"                       
%rename(Val_Switch_Topology_2549_Terminated_2_SPDT) DAQmx_Val_Switch_Topology_2549_Terminated_2_SPDT;
%feature("docstring", " 2549/Terminated 2-SPDT") Val_Switch_Topology_2549_Terminated_2_SPDT;
#define DAQmx_Val_Switch_Topology_2549_Terminated_2_SPDT          "2549/Terminated 2-SPDT"            
%rename(Val_Switch_Topology_2554_4x1_Mux) DAQmx_Val_Switch_Topology_2554_4x1_Mux;
%feature("docstring", " 2554/4x1 Mux") Val_Switch_Topology_2554_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2554_4x1_Mux                    "2554/4x1 Mux"                      
%rename(Val_Switch_Topology_2555_4x1_Terminated_Mux) DAQmx_Val_Switch_Topology_2555_4x1_Terminated_Mux;
%feature("docstring", " 2555/4x1 Terminated Mux") Val_Switch_Topology_2555_4x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_2555_4x1_Terminated_Mux         "2555/4x1 Terminated Mux"           
%rename(Val_Switch_Topology_2556_Dual_4x1_Mux) DAQmx_Val_Switch_Topology_2556_Dual_4x1_Mux;
%feature("docstring", " 2556/Dual 4x1 Mux") Val_Switch_Topology_2556_Dual_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2556_Dual_4x1_Mux               "2556/Dual 4x1 Mux"                 
%rename(Val_Switch_Topology_2557_8x1_Mux) DAQmx_Val_Switch_Topology_2557_8x1_Mux;
%feature("docstring", " 2557/8x1 Mux") Val_Switch_Topology_2557_8x1_Mux;
#define DAQmx_Val_Switch_Topology_2557_8x1_Mux                    "2557/8x1 Mux"                      
%rename(Val_Switch_Topology_2558_4_SPDT) DAQmx_Val_Switch_Topology_2558_4_SPDT;
%feature("docstring", " 2558/4-SPDT") Val_Switch_Topology_2558_4_SPDT;
#define DAQmx_Val_Switch_Topology_2558_4_SPDT                     "2558/4-SPDT"                       
%rename(Val_Switch_Topology_2559_Terminated_2_SPDT) DAQmx_Val_Switch_Topology_2559_Terminated_2_SPDT;
%feature("docstring", " 2559/Terminated 2-SPDT") Val_Switch_Topology_2559_Terminated_2_SPDT;
#define DAQmx_Val_Switch_Topology_2559_Terminated_2_SPDT          "2559/Terminated 2-SPDT"            
%rename(Val_Switch_Topology_2564_16_SPST) DAQmx_Val_Switch_Topology_2564_16_SPST;
%feature("docstring", " 2564/16-SPST") Val_Switch_Topology_2564_16_SPST;
#define DAQmx_Val_Switch_Topology_2564_16_SPST                    "2564/16-SPST"                      
%rename(Val_Switch_Topology_2564_8_DPST) DAQmx_Val_Switch_Topology_2564_8_DPST;
%feature("docstring", " 2564/8-DPST") Val_Switch_Topology_2564_8_DPST;
#define DAQmx_Val_Switch_Topology_2564_8_DPST                     "2564/8-DPST"                       
%rename(Val_Switch_Topology_2565_16_SPST) DAQmx_Val_Switch_Topology_2565_16_SPST;
%feature("docstring", " 2565/16-SPST") Val_Switch_Topology_2565_16_SPST;
#define DAQmx_Val_Switch_Topology_2565_16_SPST                    "2565/16-SPST"                      
%rename(Val_Switch_Topology_2566_16_SPDT) DAQmx_Val_Switch_Topology_2566_16_SPDT;
%feature("docstring", " 2566/16-SPDT") Val_Switch_Topology_2566_16_SPDT;
#define DAQmx_Val_Switch_Topology_2566_16_SPDT                    "2566/16-SPDT"                      
%rename(Val_Switch_Topology_2566_8_DPDT) DAQmx_Val_Switch_Topology_2566_8_DPDT;
%feature("docstring", " 2566/8-DPDT") Val_Switch_Topology_2566_8_DPDT;
#define DAQmx_Val_Switch_Topology_2566_8_DPDT                     "2566/8-DPDT"                       
%rename(Val_Switch_Topology_2567_Independent) DAQmx_Val_Switch_Topology_2567_Independent;
%feature("docstring", " 2567/Independent") Val_Switch_Topology_2567_Independent;
#define DAQmx_Val_Switch_Topology_2567_Independent                "2567/Independent"                  
%rename(Val_Switch_Topology_2568_31_SPST) DAQmx_Val_Switch_Topology_2568_31_SPST;
%feature("docstring", " 2568/31-SPST") Val_Switch_Topology_2568_31_SPST;
#define DAQmx_Val_Switch_Topology_2568_31_SPST                    "2568/31-SPST"                      
%rename(Val_Switch_Topology_2568_15_DPST) DAQmx_Val_Switch_Topology_2568_15_DPST;
%feature("docstring", " 2568/15-DPST") Val_Switch_Topology_2568_15_DPST;
#define DAQmx_Val_Switch_Topology_2568_15_DPST                    "2568/15-DPST"                      
%rename(Val_Switch_Topology_2569_100_SPST) DAQmx_Val_Switch_Topology_2569_100_SPST;
%feature("docstring", " 2569/100-SPST") Val_Switch_Topology_2569_100_SPST;
#define DAQmx_Val_Switch_Topology_2569_100_SPST                   "2569/100-SPST"                     
%rename(Val_Switch_Topology_2569_50_DPST) DAQmx_Val_Switch_Topology_2569_50_DPST;
%feature("docstring", " 2569/50-DPST") Val_Switch_Topology_2569_50_DPST;
#define DAQmx_Val_Switch_Topology_2569_50_DPST                    "2569/50-DPST"                      
%rename(Val_Switch_Topology_2570_40_SPDT) DAQmx_Val_Switch_Topology_2570_40_SPDT;
%feature("docstring", " 2570/40-SPDT") Val_Switch_Topology_2570_40_SPDT;
#define DAQmx_Val_Switch_Topology_2570_40_SPDT                    "2570/40-SPDT"                      
%rename(Val_Switch_Topology_2570_20_DPDT) DAQmx_Val_Switch_Topology_2570_20_DPDT;
%feature("docstring", " 2570/20-DPDT") Val_Switch_Topology_2570_20_DPDT;
#define DAQmx_Val_Switch_Topology_2570_20_DPDT                    "2570/20-DPDT"                      
%rename(Val_Switch_Topology_2575_1_Wire_196x1_Mux) DAQmx_Val_Switch_Topology_2575_1_Wire_196x1_Mux;
%feature("docstring", " 2575/1-Wire 196x1 Mux") Val_Switch_Topology_2575_1_Wire_196x1_Mux;
#define DAQmx_Val_Switch_Topology_2575_1_Wire_196x1_Mux           "2575/1-Wire 196x1 Mux"             
%rename(Val_Switch_Topology_2575_2_Wire_98x1_Mux) DAQmx_Val_Switch_Topology_2575_2_Wire_98x1_Mux;
%feature("docstring", " 2575/2-Wire 98x1 Mux") Val_Switch_Topology_2575_2_Wire_98x1_Mux;
#define DAQmx_Val_Switch_Topology_2575_2_Wire_98x1_Mux            "2575/2-Wire 98x1 Mux"              
%rename(Val_Switch_Topology_2575_2_Wire_95x1_Mux) DAQmx_Val_Switch_Topology_2575_2_Wire_95x1_Mux;
%feature("docstring", " 2575/2-Wire 95x1 Mux") Val_Switch_Topology_2575_2_Wire_95x1_Mux;
#define DAQmx_Val_Switch_Topology_2575_2_Wire_95x1_Mux            "2575/2-Wire 95x1 Mux"              
%rename(Val_Switch_Topology_2576_2_Wire_64x1_Mux) DAQmx_Val_Switch_Topology_2576_2_Wire_64x1_Mux;
%feature("docstring", " 2576/2-Wire 64x1 Mux") Val_Switch_Topology_2576_2_Wire_64x1_Mux;
#define DAQmx_Val_Switch_Topology_2576_2_Wire_64x1_Mux            "2576/2-Wire 64x1 Mux"              
%rename(Val_Switch_Topology_2576_2_Wire_Dual_32x1_Mux) DAQmx_Val_Switch_Topology_2576_2_Wire_Dual_32x1_Mux;
%feature("docstring", " 2576/2-Wire Dual 32x1 Mux") Val_Switch_Topology_2576_2_Wire_Dual_32x1_Mux;
#define DAQmx_Val_Switch_Topology_2576_2_Wire_Dual_32x1_Mux       "2576/2-Wire Dual 32x1 Mux"         
%rename(Val_Switch_Topology_2576_2_Wire_Octal_8x1_Mux) DAQmx_Val_Switch_Topology_2576_2_Wire_Octal_8x1_Mux;
%feature("docstring", " 2576/2-Wire Octal 8x1 Mux") Val_Switch_Topology_2576_2_Wire_Octal_8x1_Mux;
#define DAQmx_Val_Switch_Topology_2576_2_Wire_Octal_8x1_Mux       "2576/2-Wire Octal 8x1 Mux"         
%rename(Val_Switch_Topology_2576_2_Wire_Quad_16x1_Mux) DAQmx_Val_Switch_Topology_2576_2_Wire_Quad_16x1_Mux;
%feature("docstring", " 2576/2-Wire Quad 16x1 Mux") Val_Switch_Topology_2576_2_Wire_Quad_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2576_2_Wire_Quad_16x1_Mux       "2576/2-Wire Quad 16x1 Mux"         
%rename(Val_Switch_Topology_2576_2_Wire_Sixteen_4x1_Mux) DAQmx_Val_Switch_Topology_2576_2_Wire_Sixteen_4x1_Mux;
%feature("docstring", " 2576/2-Wire Sixteen 4x1 Mux") Val_Switch_Topology_2576_2_Wire_Sixteen_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2576_2_Wire_Sixteen_4x1_Mux     "2576/2-Wire Sixteen 4x1 Mux"       
%rename(Val_Switch_Topology_2576_Independent) DAQmx_Val_Switch_Topology_2576_Independent;
%feature("docstring", " 2576/Independent") Val_Switch_Topology_2576_Independent;
#define DAQmx_Val_Switch_Topology_2576_Independent                "2576/Independent"                  
%rename(Val_Switch_Topology_2584_1_Wire_12x1_Mux) DAQmx_Val_Switch_Topology_2584_1_Wire_12x1_Mux;
%feature("docstring", " 2584/1-Wire 12x1 Mux") Val_Switch_Topology_2584_1_Wire_12x1_Mux;
#define DAQmx_Val_Switch_Topology_2584_1_Wire_12x1_Mux            "2584/1-Wire 12x1 Mux"              
%rename(Val_Switch_Topology_2584_1_Wire_Dual_6x1_Mux) DAQmx_Val_Switch_Topology_2584_1_Wire_Dual_6x1_Mux;
%feature("docstring", " 2584/1-Wire Dual 6x1 Mux") Val_Switch_Topology_2584_1_Wire_Dual_6x1_Mux;
#define DAQmx_Val_Switch_Topology_2584_1_Wire_Dual_6x1_Mux        "2584/1-Wire Dual 6x1 Mux"          
%rename(Val_Switch_Topology_2584_2_Wire_6x1_Mux) DAQmx_Val_Switch_Topology_2584_2_Wire_6x1_Mux;
%feature("docstring", " 2584/2-Wire 6x1 Mux") Val_Switch_Topology_2584_2_Wire_6x1_Mux;
#define DAQmx_Val_Switch_Topology_2584_2_Wire_6x1_Mux             "2584/2-Wire 6x1 Mux"               
%rename(Val_Switch_Topology_2584_Independent) DAQmx_Val_Switch_Topology_2584_Independent;
%feature("docstring", " 2584/Independent") Val_Switch_Topology_2584_Independent;
#define DAQmx_Val_Switch_Topology_2584_Independent                "2584/Independent"                  
%rename(Val_Switch_Topology_2585_1_Wire_10x1_Mux) DAQmx_Val_Switch_Topology_2585_1_Wire_10x1_Mux;
%feature("docstring", " 2585/1-Wire 10x1 Mux") Val_Switch_Topology_2585_1_Wire_10x1_Mux;
#define DAQmx_Val_Switch_Topology_2585_1_Wire_10x1_Mux            "2585/1-Wire 10x1 Mux"              
%rename(Val_Switch_Topology_2586_10_SPST) DAQmx_Val_Switch_Topology_2586_10_SPST;
%feature("docstring", " 2586/10-SPST") Val_Switch_Topology_2586_10_SPST;
#define DAQmx_Val_Switch_Topology_2586_10_SPST                    "2586/10-SPST"                      
%rename(Val_Switch_Topology_2586_5_DPST) DAQmx_Val_Switch_Topology_2586_5_DPST;
%feature("docstring", " 2586/5-DPST") Val_Switch_Topology_2586_5_DPST;
#define DAQmx_Val_Switch_Topology_2586_5_DPST                     "2586/5-DPST"                       
%rename(Val_Switch_Topology_2590_4x1_Mux) DAQmx_Val_Switch_Topology_2590_4x1_Mux;
%feature("docstring", " 2590/4x1 Mux") Val_Switch_Topology_2590_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2590_4x1_Mux                    "2590/4x1 Mux"                      
%rename(Val_Switch_Topology_2591_4x1_Mux) DAQmx_Val_Switch_Topology_2591_4x1_Mux;
%feature("docstring", " 2591/4x1 Mux") Val_Switch_Topology_2591_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2591_4x1_Mux                    "2591/4x1 Mux"                      
%rename(Val_Switch_Topology_2593_16x1_Mux) DAQmx_Val_Switch_Topology_2593_16x1_Mux;
%feature("docstring", " 2593/16x1 Mux") Val_Switch_Topology_2593_16x1_Mux;
#define DAQmx_Val_Switch_Topology_2593_16x1_Mux                   "2593/16x1 Mux"                     
%rename(Val_Switch_Topology_2593_Dual_8x1_Mux) DAQmx_Val_Switch_Topology_2593_Dual_8x1_Mux;
%feature("docstring", " 2593/Dual 8x1 Mux") Val_Switch_Topology_2593_Dual_8x1_Mux;
#define DAQmx_Val_Switch_Topology_2593_Dual_8x1_Mux               "2593/Dual 8x1 Mux"                 
%rename(Val_Switch_Topology_2593_8x1_Terminated_Mux) DAQmx_Val_Switch_Topology_2593_8x1_Terminated_Mux;
%feature("docstring", " 2593/8x1 Terminated Mux") Val_Switch_Topology_2593_8x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_2593_8x1_Terminated_Mux         "2593/8x1 Terminated Mux"           
%rename(Val_Switch_Topology_2593_Dual_4x1_Terminated_Mux) DAQmx_Val_Switch_Topology_2593_Dual_4x1_Terminated_Mux;
%feature("docstring", " 2593/Dual 4x1 Terminated Mux") Val_Switch_Topology_2593_Dual_4x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_2593_Dual_4x1_Terminated_Mux    "2593/Dual 4x1 Terminated Mux"      
%rename(Val_Switch_Topology_2593_Independent) DAQmx_Val_Switch_Topology_2593_Independent;
%feature("docstring", " 2593/Independent") Val_Switch_Topology_2593_Independent;
#define DAQmx_Val_Switch_Topology_2593_Independent                "2593/Independent"                  
%rename(Val_Switch_Topology_2594_4x1_Mux) DAQmx_Val_Switch_Topology_2594_4x1_Mux;
%feature("docstring", " 2594/4x1 Mux") Val_Switch_Topology_2594_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2594_4x1_Mux                    "2594/4x1 Mux"                      
%rename(Val_Switch_Topology_2595_4x1_Mux) DAQmx_Val_Switch_Topology_2595_4x1_Mux;
%feature("docstring", " 2595/4x1 Mux") Val_Switch_Topology_2595_4x1_Mux;
#define DAQmx_Val_Switch_Topology_2595_4x1_Mux                    "2595/4x1 Mux"                      
%rename(Val_Switch_Topology_2596_Dual_6x1_Mux) DAQmx_Val_Switch_Topology_2596_Dual_6x1_Mux;
%feature("docstring", " 2596/Dual 6x1 Mux") Val_Switch_Topology_2596_Dual_6x1_Mux;
#define DAQmx_Val_Switch_Topology_2596_Dual_6x1_Mux               "2596/Dual 6x1 Mux"                 
%rename(Val_Switch_Topology_2597_6x1_Terminated_Mux) DAQmx_Val_Switch_Topology_2597_6x1_Terminated_Mux;
%feature("docstring", " 2597/6x1 Terminated Mux") Val_Switch_Topology_2597_6x1_Terminated_Mux;
#define DAQmx_Val_Switch_Topology_2597_6x1_Terminated_Mux         "2597/6x1 Terminated Mux"           
%rename(Val_Switch_Topology_2598_Dual_Transfer) DAQmx_Val_Switch_Topology_2598_Dual_Transfer;
%feature("docstring", " 2598/Dual Transfer") Val_Switch_Topology_2598_Dual_Transfer;
#define DAQmx_Val_Switch_Topology_2598_Dual_Transfer              "2598/Dual Transfer"                
%rename(Val_Switch_Topology_2599_2_SPDT) DAQmx_Val_Switch_Topology_2599_2_SPDT;
%feature("docstring", " 2599/2-SPDT") Val_Switch_Topology_2599_2_SPDT;
#define DAQmx_Val_Switch_Topology_2599_2_SPDT                     "2599/2-SPDT"                       

%rename(SwitchSetTopologyAndReset) DAQmxSwitchSetTopologyAndReset;
int32 __CFUNC     DAQmxSwitchSetTopologyAndReset (const char deviceName[], const char newTopology[]);

// For possible values of the output parameter pathStatus see value set SwitchPathType in Values section above.
%rename(SwitchFindPath) DAQmxSwitchFindPath;
int32 __CFUNC     DAQmxSwitchFindPath            (const char switchChannel1[], const char switchChannel2[], char path[], uInt32 pathBufferSize, int32 *pathStatus);

%rename(SwitchOpenRelays) DAQmxSwitchOpenRelays;
int32 __CFUNC     DAQmxSwitchOpenRelays          (const char relayList[], bool32 waitForSettling);
%rename(SwitchCloseRelays) DAQmxSwitchCloseRelays;
int32 __CFUNC     DAQmxSwitchCloseRelays         (const char relayList[], bool32 waitForSettling);

%rename(SwitchGetSingleRelayCount) DAQmxSwitchGetSingleRelayCount;
int32 __CFUNC     DAQmxSwitchGetSingleRelayCount (const char relayName[], uInt32 *count);
%rename(SwitchGetMultiRelayCount) DAQmxSwitchGetMultiRelayCount;
int32 __CFUNC     DAQmxSwitchGetMultiRelayCount  (const char relayList[], uInt32 count[], uInt32 countArraySize, uInt32 *numRelayCountsRead);
// For possible values of the output parameter relayPos see value set RelayPos in Values section above.
%rename(SwitchGetSingleRelayPos) DAQmxSwitchGetSingleRelayPos;
int32 __CFUNC     DAQmxSwitchGetSingleRelayPos   (const char relayName[], uInt32 *relayPos);
// For possible values in the output array relayPos see value set RelayPos in Values section above.
%rename(SwitchGetMultiRelayPos) DAQmxSwitchGetMultiRelayPos;
int32 __CFUNC     DAQmxSwitchGetMultiRelayPos    (const char relayList[], uInt32 relayPos[], uInt32 relayPosArraySize, uInt32 *numRelayPossRead);

%rename(SwitchWaitForSettling) DAQmxSwitchWaitForSettling;
int32 __CFUNC     DAQmxSwitchWaitForSettling     (const char deviceName[]);

%rename(GetSwitchChanAttribute) DAQmxGetSwitchChanAttribute;
int32 __CFUNC_C   DAQmxGetSwitchChanAttribute    (const char switchChannelName[], int32 attribute, void *value);
%rename(SetSwitchChanAttribute) DAQmxSetSwitchChanAttribute;
int32 __CFUNC_C   DAQmxSetSwitchChanAttribute    (const char switchChannelName[], int32 attribute, ...);

%rename(GetSwitchDeviceAttribute) DAQmxGetSwitchDeviceAttribute;
int32 __CFUNC_C   DAQmxGetSwitchDeviceAttribute  (const char deviceName[], int32 attribute, void *value, ...);
%rename(SetSwitchDeviceAttribute) DAQmxSetSwitchDeviceAttribute;
int32 __CFUNC_C   DAQmxSetSwitchDeviceAttribute  (const char deviceName[], int32 attribute, ...);

%rename(GetSwitchScanAttribute) DAQmxGetSwitchScanAttribute;
int32 __CFUNC_C   DAQmxGetSwitchScanAttribute    (TaskHandle taskHandle, int32 attribute, void *value);
%rename(SetSwitchScanAttribute) DAQmxSetSwitchScanAttribute;
int32 __CFUNC_C   DAQmxSetSwitchScanAttribute    (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetSwitchScanAttribute) DAQmxResetSwitchScanAttribute;
int32 __CFUNC     DAQmxResetSwitchScanAttribute  (TaskHandle taskHandle, int32 attribute);



/** Calibration
 **/


%rename(SelfCal) DAQmxSelfCal;
int32 __CFUNC     DAQmxSelfCal                    (const char deviceName[]);
%rename(PerformBridgeOffsetNullingCal) DAQmxPerformBridgeOffsetNullingCal;
int32 __CFUNC     DAQmxPerformBridgeOffsetNullingCal(TaskHandle taskHandle, const char channel[]);
%rename(PerformBridgeOffsetNullingCalEx) DAQmxPerformBridgeOffsetNullingCalEx;
int32 __CFUNC     DAQmxPerformBridgeOffsetNullingCalEx(TaskHandle taskHandle, const char channel[], bool32 skipUnsupportedChannels);
%rename(PerformStrainShuntCal) DAQmxPerformStrainShuntCal;
int32 __CFUNC     DAQmxPerformStrainShuntCal      (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, bool32 skipUnsupportedChannels);
%rename(PerformBridgeShuntCal) DAQmxPerformBridgeShuntCal;
int32 __CFUNC     DAQmxPerformBridgeShuntCal      (TaskHandle taskHandle, const char channel[], float64 shuntResistorValue, int32 shuntResistorLocation, float64 bridgeResistance, bool32 skipUnsupportedChannels);
%rename(GetSelfCalLastDateAndTime) DAQmxGetSelfCalLastDateAndTime;
int32 __CFUNC     DAQmxGetSelfCalLastDateAndTime  (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);
%rename(GetExtCalLastDateAndTime) DAQmxGetExtCalLastDateAndTime;
int32 __CFUNC     DAQmxGetExtCalLastDateAndTime   (const char deviceName[], uInt32 *year, uInt32 *month, uInt32 *day, uInt32 *hour, uInt32 *minute);
%rename(RestoreLastExtCalConst) DAQmxRestoreLastExtCalConst;
int32 __CFUNC     DAQmxRestoreLastExtCalConst     (const char deviceName[]);

%rename(ESeriesCalAdjust) DAQmxESeriesCalAdjust;
int32 __CFUNC     DAQmxESeriesCalAdjust           (CalHandle calHandle, float64 referenceVoltage);
%rename(MSeriesCalAdjust) DAQmxMSeriesCalAdjust;
int32 __CFUNC     DAQmxMSeriesCalAdjust           (CalHandle calHandle, float64 referenceVoltage);
%rename(SSeriesCalAdjust) DAQmxSSeriesCalAdjust;
int32 __CFUNC     DAQmxSSeriesCalAdjust           (CalHandle calHandle, float64 referenceVoltage);
%rename(SCBaseboardCalAdjust) DAQmxSCBaseboardCalAdjust;
int32 __CFUNC     DAQmxSCBaseboardCalAdjust       (CalHandle calHandle, float64 referenceVoltage);
%rename(AOSeriesCalAdjust) DAQmxAOSeriesCalAdjust;
int32 __CFUNC     DAQmxAOSeriesCalAdjust          (CalHandle calHandle, float64 referenceVoltage);

%rename(DeviceSupportsCal) DAQmxDeviceSupportsCal;
int32 __CFUNC     DAQmxDeviceSupportsCal          (const char deviceName[], bool32 *calSupported);

%rename(GetCalInfoAttribute) DAQmxGetCalInfoAttribute;
int32 __CFUNC_C   DAQmxGetCalInfoAttribute        (const char deviceName[], int32 attribute, void *value, ...);
%rename(SetCalInfoAttribute) DAQmxSetCalInfoAttribute;
int32 __CFUNC_C   DAQmxSetCalInfoAttribute        (const char deviceName[], int32 attribute, ...);

%rename(InitExtCal) DAQmxInitExtCal;
int32 __CFUNC     DAQmxInitExtCal                 (const char deviceName[], const char password[], CalHandle *calHandle);
%rename(CloseExtCal) DAQmxCloseExtCal;
int32 __CFUNC     DAQmxCloseExtCal                (CalHandle calHandle, int32 action);
%rename(ChangeExtCalPassword) DAQmxChangeExtCalPassword;
int32 __CFUNC     DAQmxChangeExtCalPassword       (const char deviceName[], const char password[], const char newPassword[]);

%rename(AdjustDSAAICal) DAQmxAdjustDSAAICal;
int32 __CFUNC     DAQmxAdjustDSAAICal             (CalHandle calHandle, float64 referenceVoltage);
%rename(AdjustDSAAICalEx) DAQmxAdjustDSAAICalEx;
int32 __CFUNC     DAQmxAdjustDSAAICalEx           (CalHandle calHandle, float64 referenceVoltage, bool32 inputsShorted);
%rename(AdjustDSAAOCal) DAQmxAdjustDSAAOCal;
int32 __CFUNC     DAQmxAdjustDSAAOCal             (CalHandle calHandle, uInt32 channel, float64 requestedLowVoltage, float64 actualLowVoltage, float64 requestedHighVoltage, float64 actualHighVoltage, float64 gainSetting);
%rename(AdjustDSATimebaseCal) DAQmxAdjustDSATimebaseCal;
int32 __CFUNC     DAQmxAdjustDSATimebaseCal       (CalHandle calHandle, float64 referenceFrequency);

%rename(Adjust4204Cal) DAQmxAdjust4204Cal;
int32 __CFUNC     DAQmxAdjust4204Cal              (CalHandle calHandle, const char channelNames[], float64 lowPassFreq, bool32 trackHoldEnabled, float64 inputVal);
%rename(Adjust4220Cal) DAQmxAdjust4220Cal;
int32 __CFUNC     DAQmxAdjust4220Cal              (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);
%rename(Adjust4224Cal) DAQmxAdjust4224Cal;
int32 __CFUNC     DAQmxAdjust4224Cal              (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);
// Note: This function is obsolete and now always returns zero.
%rename(Adjust4225Cal) DAQmxAdjust4225Cal;
int32 __CFUNC     DAQmxAdjust4225Cal              (CalHandle calHandle, const char channelNames[], float64 gain, float64 inputVal);

%rename(Setup1102Cal) DAQmxSetup1102Cal;
int32 __CFUNC     DAQmxSetup1102Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1102Cal) DAQmxAdjust1102Cal;
int32 __CFUNC     DAQmxAdjust1102Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1104Cal) DAQmxSetup1104Cal;
int32 __CFUNC     DAQmxSetup1104Cal               (CalHandle calHandle, const char channelName[]);
%rename(Adjust1104Cal) DAQmxAdjust1104Cal;
int32 __CFUNC     DAQmxAdjust1104Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1112Cal) DAQmxSetup1112Cal;
int32 __CFUNC     DAQmxSetup1112Cal               (CalHandle calHandle, const char channelName[]);
%rename(Adjust1112Cal) DAQmxAdjust1112Cal;
int32 __CFUNC     DAQmxAdjust1112Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1122Cal) DAQmxSetup1122Cal;
int32 __CFUNC     DAQmxSetup1122Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1122Cal) DAQmxAdjust1122Cal;
int32 __CFUNC     DAQmxAdjust1122Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1124Cal) DAQmxSetup1124Cal;
int32 __CFUNC     DAQmxSetup1124Cal               (CalHandle calHandle, const char channelName[], int32 range, uInt32 dacValue);
%rename(Adjust1124Cal) DAQmxAdjust1124Cal;
int32 __CFUNC     DAQmxAdjust1124Cal              (CalHandle calHandle, float64 measOutput);

%rename(Setup1125Cal) DAQmxSetup1125Cal;
int32 __CFUNC     DAQmxSetup1125Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1125Cal) DAQmxAdjust1125Cal;
int32 __CFUNC     DAQmxAdjust1125Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1126Cal) DAQmxSetup1126Cal;
int32 __CFUNC     DAQmxSetup1126Cal               (CalHandle calHandle, const char channelName[], float64 upperFreqLimit);
%rename(Adjust1126Cal) DAQmxAdjust1126Cal;
int32 __CFUNC     DAQmxAdjust1126Cal              (CalHandle calHandle, float64 refFreq, float64 measOutput);

%rename(Setup1141Cal) DAQmxSetup1141Cal;
int32 __CFUNC     DAQmxSetup1141Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1141Cal) DAQmxAdjust1141Cal;
int32 __CFUNC     DAQmxAdjust1141Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);
%rename(Setup1142Cal) DAQmxSetup1142Cal;
int32 __CFUNC     DAQmxSetup1142Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1142Cal) DAQmxAdjust1142Cal;
int32 __CFUNC     DAQmxAdjust1142Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);
%rename(Setup1143Cal) DAQmxSetup1143Cal;
int32 __CFUNC     DAQmxSetup1143Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1143Cal) DAQmxAdjust1143Cal;
int32 __CFUNC     DAQmxAdjust1143Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);


%rename(Setup1502Cal) DAQmxSetup1502Cal;
int32 __CFUNC     DAQmxSetup1502Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1502Cal) DAQmxAdjust1502Cal;
int32 __CFUNC     DAQmxAdjust1502Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1503Cal) DAQmxSetup1503Cal;
int32 __CFUNC     DAQmxSetup1503Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1503Cal) DAQmxAdjust1503Cal;
int32 __CFUNC     DAQmxAdjust1503Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);
%rename(Adjust1503CurrentCal) DAQmxAdjust1503CurrentCal;
int32 __CFUNC     DAQmxAdjust1503CurrentCal       (CalHandle calHandle, const char channelName[], float64 measCurrent);

%rename(Setup1520Cal) DAQmxSetup1520Cal;
int32 __CFUNC     DAQmxSetup1520Cal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust1520Cal) DAQmxAdjust1520Cal;
int32 __CFUNC     DAQmxAdjust1520Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1521Cal) DAQmxSetup1521Cal;
int32 __CFUNC     DAQmxSetup1521Cal               (CalHandle calHandle, const char channelName[]);
%rename(Adjust1521Cal) DAQmxAdjust1521Cal;
int32 __CFUNC     DAQmxAdjust1521Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup153xCal) DAQmxSetup153xCal;
int32 __CFUNC     DAQmxSetup153xCal               (CalHandle calHandle, const char channelName[], float64 gain);
%rename(Adjust153xCal) DAQmxAdjust153xCal;
int32 __CFUNC     DAQmxAdjust153xCal              (CalHandle calHandle, float64 refVoltage, float64 measOutput);

%rename(Setup1540Cal) DAQmxSetup1540Cal;
int32 __CFUNC     DAQmxSetup1540Cal               (CalHandle calHandle, const char channelName[], float64 excitationVoltage, float64 excitationFreq);
%rename(Adjust1540Cal) DAQmxAdjust1540Cal;
int32 __CFUNC     DAQmxAdjust1540Cal              (CalHandle calHandle, float64 refVoltage, float64 measOutput, int32 inputCalSource);


/** Read Data
 **/


%rename(ReadAnalogF64) DAQmxReadAnalogF64;
int32 __CFUNC     DAQmxReadAnalogF64         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadAnalogScalarF64) DAQmxReadAnalogScalarF64;
int32 __CFUNC     DAQmxReadAnalogScalarF64   (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);

%rename(ReadBinaryI16) DAQmxReadBinaryI16;
int32 __CFUNC     DAQmxReadBinaryI16         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

%rename(ReadBinaryU16) DAQmxReadBinaryU16;
int32 __CFUNC     DAQmxReadBinaryU16         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

%rename(ReadBinaryI32) DAQmxReadBinaryI32;
int32 __CFUNC     DAQmxReadBinaryI32         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, int32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

%rename(ReadBinaryU32) DAQmxReadBinaryU32;
int32 __CFUNC     DAQmxReadBinaryU32         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);

%rename(ReadDigitalU8) DAQmxReadDigitalU8;
int32 __CFUNC     DAQmxReadDigitalU8         (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt8 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadDigitalU16) DAQmxReadDigitalU16;
int32 __CFUNC     DAQmxReadDigitalU16        (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt16 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadDigitalU32) DAQmxReadDigitalU32;
int32 __CFUNC     DAQmxReadDigitalU32        (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadDigitalScalarU32) DAQmxReadDigitalScalarU32;
int32 __CFUNC     DAQmxReadDigitalScalarU32  (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);
%rename(ReadDigitalLines) DAQmxReadDigitalLines;
int32 __CFUNC	    DAQmxReadDigitalLines      (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, bool32 fillMode, uInt8 readArray[], uInt32 arraySizeInBytes, int32 *sampsPerChanRead, int32 *numBytesPerSamp, bool32 *reserved);

%rename(ReadCounterF64) DAQmxReadCounterF64;
int32 __CFUNC     DAQmxReadCounterF64        (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, float64 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadCounterU32) DAQmxReadCounterU32;
int32 __CFUNC     DAQmxReadCounterU32        (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, uInt32 readArray[], uInt32 arraySizeInSamps, int32 *sampsPerChanRead, bool32 *reserved);
%rename(ReadCounterScalarF64) DAQmxReadCounterScalarF64;
int32 __CFUNC     DAQmxReadCounterScalarF64  (TaskHandle taskHandle, float64 timeout, float64 *value, bool32 *reserved);
%rename(ReadCounterScalarU32) DAQmxReadCounterScalarU32;
int32 __CFUNC     DAQmxReadCounterScalarU32  (TaskHandle taskHandle, float64 timeout, uInt32 *value, bool32 *reserved);

%rename(ReadRaw) DAQmxReadRaw;
int32 __CFUNC     DAQmxReadRaw               (TaskHandle taskHandle, int32 numSampsPerChan, float64 timeout, void *readArray, uInt32 arraySizeInBytes, int32 *sampsRead, int32 *numBytesPerSamp, bool32 *reserved);

%rename(GetNthTaskReadChannel) DAQmxGetNthTaskReadChannel;
int32 __CFUNC     DAQmxGetNthTaskReadChannel (TaskHandle taskHandle, uInt32 index, char buffer[], int32 bufferSize);

%rename(GetReadAttribute) DAQmxGetReadAttribute;
int32 __CFUNC_C   DAQmxGetReadAttribute      (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetReadAttribute) DAQmxSetReadAttribute;
int32 __CFUNC_C   DAQmxSetReadAttribute      (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetReadAttribute) DAQmxResetReadAttribute;
int32 __CFUNC     DAQmxResetReadAttribute    (TaskHandle taskHandle, int32 attribute);


/** Real-Time
 **/

%rename(WaitForNextSampleClock) DAQmxWaitForNextSampleClock;
int32 __CFUNC     DAQmxWaitForNextSampleClock(TaskHandle taskHandle, float64 timeout, bool32 *isLate);
%rename(GetRealTimeAttribute) DAQmxGetRealTimeAttribute;
int32 __CFUNC_C   DAQmxGetRealTimeAttribute  (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetRealTimeAttribute) DAQmxSetRealTimeAttribute;
int32 __CFUNC_C   DAQmxSetRealTimeAttribute  (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetRealTimeAttribute) DAQmxResetRealTimeAttribute;
int32 __CFUNC     DAQmxResetRealTimeAttribute(TaskHandle taskHandle, int32 attribute);

// Note: This function is obsolete and now always returns zero.
%rename(IsReadOrWriteLate) DAQmxIsReadOrWriteLate;
bool32 __CFUNC    DAQmxIsReadOrWriteLate     (int32 errorCode);


/** Timing
 **/


// (Analog/Counter Timing)
%rename(CfgSampClkTiming) DAQmxCfgSampClkTiming;
int32 __CFUNC     DAQmxCfgSampClkTiming          (TaskHandle taskHandle, const char source[], float64 rate, int32 activeEdge, int32 sampleMode, uInt64 sampsPerChan);
// (Digital Timing)
%rename(CfgHandshakingTiming) DAQmxCfgHandshakingTiming;
int32 __CFUNC     DAQmxCfgHandshakingTiming      (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan);
// (Burst Import Clock Timing)
%rename(CfgBurstHandshakingTimingImportClock) DAQmxCfgBurstHandshakingTimingImportClock;
int32 __CFUNC     DAQmxCfgBurstHandshakingTimingImportClock(TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan, float64 sampleClkRate, const char sampleClkSrc[], int32 sampleClkActiveEdge, int32 pauseWhen, int32 readyEventActiveLevel);
// (Burst Export Clock Timing)
%rename(CfgBurstHandshakingTimingExportClock) DAQmxCfgBurstHandshakingTimingExportClock;
int32 __CFUNC     DAQmxCfgBurstHandshakingTimingExportClock(TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan, float64 sampleClkRate, const char sampleClkOutpTerm[], int32 sampleClkPulsePolarity, int32 pauseWhen, int32 readyEventActiveLevel);
%rename(CfgChangeDetectionTiming) DAQmxCfgChangeDetectionTiming;
int32 __CFUNC     DAQmxCfgChangeDetectionTiming  (TaskHandle taskHandle, const char risingEdgeChan[], const char fallingEdgeChan[], int32 sampleMode, uInt64 sampsPerChan);
// (Counter Timing)
%rename(CfgImplicitTiming) DAQmxCfgImplicitTiming;
int32 __CFUNC     DAQmxCfgImplicitTiming         (TaskHandle taskHandle, int32 sampleMode, uInt64 sampsPerChan);
// (Pipelined Sample Clock Timing)
%rename(CfgPipelinedSampClkTiming) DAQmxCfgPipelinedSampClkTiming;
int32 __CFUNC     DAQmxCfgPipelinedSampClkTiming (TaskHandle taskHandle, const char source[], float64 rate, int32 activeEdge, int32 sampleMode, uInt64 sampsPerChan);

%rename(GetTimingAttribute) DAQmxGetTimingAttribute;
int32 __CFUNC_C   DAQmxGetTimingAttribute        (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetTimingAttribute) DAQmxSetTimingAttribute;
int32 __CFUNC_C   DAQmxSetTimingAttribute        (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetTimingAttribute) DAQmxResetTimingAttribute;
int32 __CFUNC     DAQmxResetTimingAttribute      (TaskHandle taskHandle, int32 attribute);

%rename(GetTimingAttributeEx) DAQmxGetTimingAttributeEx;
int32 __CFUNC_C   DAQmxGetTimingAttributeEx      (TaskHandle taskHandle, const char deviceNames[], int32 attribute, void *value, ...);
%rename(SetTimingAttributeEx) DAQmxSetTimingAttributeEx;
int32 __CFUNC_C   DAQmxSetTimingAttributeEx      (TaskHandle taskHandle, const char deviceNames[], int32 attribute, ...);
%rename(ResetTimingAttributeEx) DAQmxResetTimingAttributeEx;
int32 __CFUNC     DAQmxResetTimingAttributeEx    (TaskHandle taskHandle, const char deviceNames[], int32 attribute);


/** TEDS
 **/

%rename(ConfigureTEDS) DAQmxConfigureTEDS;
int32 __CFUNC     DAQmxConfigureTEDS              (const char physicalChannel[], const char filePath[]);
%rename(ClearTEDS) DAQmxClearTEDS;
int32 __CFUNC     DAQmxClearTEDS                  (const char physicalChannel[]);
%rename(WriteToTEDSFromArray) DAQmxWriteToTEDSFromArray;
int32 __CFUNC     DAQmxWriteToTEDSFromArray       (const char physicalChannel[], const uInt8 bitStream[], uInt32 arraySize, int32 basicTEDSOptions);
%rename(WriteToTEDSFromFile) DAQmxWriteToTEDSFromFile;
int32 __CFUNC     DAQmxWriteToTEDSFromFile        (const char physicalChannel[], const char filePath[], int32 basicTEDSOptions);
%rename(GetPhysicalChanAttribute) DAQmxGetPhysicalChanAttribute;
int32 __CFUNC_C   DAQmxGetPhysicalChanAttribute   (const char physicalChannel[], int32 attribute, void *value, ...);


/** Device Control
 **/


%rename(ResetDevice) DAQmxResetDevice;
int32 __CFUNC     DAQmxResetDevice              (const char deviceName[]);

%rename(SelfTestDevice) DAQmxSelfTestDevice;
int32 __CFUNC     DAQmxSelfTestDevice           (const char deviceName[]);

%rename(GetDeviceAttribute) DAQmxGetDeviceAttribute;
int32 __CFUNC_C   DAQmxGetDeviceAttribute       (const char deviceName[], int32 attribute, void *value, ...);

/** System Configuration
 **/

%rename(GetSystemInfoAttribute) DAQmxGetSystemInfoAttribute;
int32 __CFUNC_C   DAQmxGetSystemInfoAttribute (int32 attribute, void *value, ...);
%rename(SetDigitalPowerUpStates) DAQmxSetDigitalPowerUpStates;
int32 __CFUNC_C   DAQmxSetDigitalPowerUpStates(const char deviceName[], const char channelNames[], int32 state, ...);
%rename(SetAnalogPowerUpStates) DAQmxSetAnalogPowerUpStates;
int32 __CFUNC_C   DAQmxSetAnalogPowerUpStates(const char deviceName[], const char channelNames[], float64 state, int32 channelType, ...);
%rename(SetDigitalLogicFamilyPowerUpState) DAQmxSetDigitalLogicFamilyPowerUpState;
int32 __CFUNC     DAQmxSetDigitalLogicFamilyPowerUpState(const char deviceName[], int32 logicFamily);

/** Triggering
 **/


%rename(DisableStartTrig) DAQmxDisableStartTrig;
int32 __CFUNC     DAQmxDisableStartTrig      (TaskHandle taskHandle);
%rename(CfgDigEdgeStartTrig) DAQmxCfgDigEdgeStartTrig;
int32 __CFUNC     DAQmxCfgDigEdgeStartTrig   (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge);
%rename(CfgAnlgEdgeStartTrig) DAQmxCfgAnlgEdgeStartTrig;
int32 __CFUNC     DAQmxCfgAnlgEdgeStartTrig  (TaskHandle taskHandle, const char triggerSource[], int32 triggerSlope, float64 triggerLevel);
%rename(CfgAnlgWindowStartTrig) DAQmxCfgAnlgWindowStartTrig;
int32 __CFUNC     DAQmxCfgAnlgWindowStartTrig(TaskHandle taskHandle, const char triggerSource[], int32 triggerWhen, float64 windowTop, float64 windowBottom);
%rename(CfgDigPatternStartTrig) DAQmxCfgDigPatternStartTrig;
int32 __CFUNC     DAQmxCfgDigPatternStartTrig(TaskHandle taskHandle, const char triggerSource[], const char triggerPattern[], int32 triggerWhen);

%rename(DisableRefTrig) DAQmxDisableRefTrig;
int32 __CFUNC     DAQmxDisableRefTrig        (TaskHandle taskHandle);
%rename(CfgDigEdgeRefTrig) DAQmxCfgDigEdgeRefTrig;
int32 __CFUNC     DAQmxCfgDigEdgeRefTrig     (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge, uInt32 pretriggerSamples);
%rename(CfgAnlgEdgeRefTrig) DAQmxCfgAnlgEdgeRefTrig;
int32 __CFUNC     DAQmxCfgAnlgEdgeRefTrig    (TaskHandle taskHandle, const char triggerSource[], int32 triggerSlope, float64 triggerLevel, uInt32 pretriggerSamples);
%rename(CfgAnlgWindowRefTrig) DAQmxCfgAnlgWindowRefTrig;
int32 __CFUNC     DAQmxCfgAnlgWindowRefTrig  (TaskHandle taskHandle, const char triggerSource[], int32 triggerWhen, float64 windowTop, float64 windowBottom, uInt32 pretriggerSamples);
%rename(CfgDigPatternRefTrig) DAQmxCfgDigPatternRefTrig;
int32 __CFUNC     DAQmxCfgDigPatternRefTrig  (TaskHandle taskHandle, const char triggerSource[], const char triggerPattern[], int32 triggerWhen, uInt32 pretriggerSamples);

%rename(DisableAdvTrig) DAQmxDisableAdvTrig;
int32 __CFUNC     DAQmxDisableAdvTrig        (TaskHandle taskHandle);
%rename(CfgDigEdgeAdvTrig) DAQmxCfgDigEdgeAdvTrig;
int32 __CFUNC     DAQmxCfgDigEdgeAdvTrig     (TaskHandle taskHandle, const char triggerSource[], int32 triggerEdge);

%rename(GetTrigAttribute) DAQmxGetTrigAttribute;
int32 __CFUNC_C   DAQmxGetTrigAttribute      (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetTrigAttribute) DAQmxSetTrigAttribute;
int32 __CFUNC_C   DAQmxSetTrigAttribute      (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetTrigAttribute) DAQmxResetTrigAttribute;
int32 __CFUNC     DAQmxResetTrigAttribute    (TaskHandle taskHandle, int32 attribute);

%rename(SendSoftwareTrigger) DAQmxSendSoftwareTrigger;
int32 __CFUNC     DAQmxSendSoftwareTrigger   (TaskHandle taskHandle, int32 triggerID);


/** Write Data
 **/


%rename(WriteAnalogF64) DAQmxWriteAnalogF64;
int32 __CFUNC     DAQmxWriteAnalogF64          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const float64 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteAnalogScalarF64) DAQmxWriteAnalogScalarF64;
int32 __CFUNC     DAQmxWriteAnalogScalarF64    (TaskHandle taskHandle, bool32 autoStart, float64 timeout, float64 value, bool32 *reserved);

%rename(WriteBinaryI16) DAQmxWriteBinaryI16;
int32 __CFUNC     DAQmxWriteBinaryI16          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const int16 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteBinaryU16) DAQmxWriteBinaryU16;
int32 __CFUNC     DAQmxWriteBinaryU16          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt16 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteBinaryI32) DAQmxWriteBinaryI32;
int32 __CFUNC     DAQmxWriteBinaryI32          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const int32 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteBinaryU32) DAQmxWriteBinaryU32;
int32 __CFUNC     DAQmxWriteBinaryU32          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt32 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);

%rename(WriteDigitalU8) DAQmxWriteDigitalU8;
int32 __CFUNC     DAQmxWriteDigitalU8          (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt8 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteDigitalU16) DAQmxWriteDigitalU16;
int32 __CFUNC     DAQmxWriteDigitalU16         (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt16 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteDigitalU32) DAQmxWriteDigitalU32;
int32 __CFUNC     DAQmxWriteDigitalU32         (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt32 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);
%rename(WriteDigitalScalarU32) DAQmxWriteDigitalScalarU32;
int32 __CFUNC     DAQmxWriteDigitalScalarU32   (TaskHandle taskHandle, bool32 autoStart, float64 timeout, uInt32 value, bool32 *reserved);
%rename(WriteDigitalLines) DAQmxWriteDigitalLines;
int32 __CFUNC     DAQmxWriteDigitalLines       (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt8 writeArray[], int32 *sampsPerChanWritten, bool32 *reserved);

%rename(WriteCtrFreq) DAQmxWriteCtrFreq;
int32 __CFUNC     DAQmxWriteCtrFreq            (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const float64 frequency[], const float64 dutyCycle[], int32 *numSampsPerChanWritten, bool32 *reserved);
%rename(WriteCtrFreqScalar) DAQmxWriteCtrFreqScalar;
int32 __CFUNC     DAQmxWriteCtrFreqScalar      (TaskHandle taskHandle, bool32 autoStart, float64 timeout, float64 frequency, float64 dutyCycle, bool32 *reserved);
%rename(WriteCtrTime) DAQmxWriteCtrTime;
int32 __CFUNC     DAQmxWriteCtrTime            (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const float64 highTime[], const float64 lowTime[], int32 *numSampsPerChanWritten, bool32 *reserved);
%rename(WriteCtrTimeScalar) DAQmxWriteCtrTimeScalar;
int32 __CFUNC     DAQmxWriteCtrTimeScalar      (TaskHandle taskHandle, bool32 autoStart, float64 timeout, float64 highTime, float64 lowTime, bool32 *reserved);
%rename(WriteCtrTicks) DAQmxWriteCtrTicks;
int32 __CFUNC     DAQmxWriteCtrTicks           (TaskHandle taskHandle, int32 numSampsPerChan, bool32 autoStart, float64 timeout, bool32 dataLayout, const uInt32 highTicks[], const uInt32 lowTicks[], int32 *numSampsPerChanWritten, bool32 *reserved);
%rename(WriteCtrTicksScalar) DAQmxWriteCtrTicksScalar;
int32 __CFUNC     DAQmxWriteCtrTicksScalar     (TaskHandle taskHandle, bool32 autoStart, float64 timeout, uInt32 highTicks, uInt32 lowTicks, bool32 *reserved);

%rename(WriteRaw) DAQmxWriteRaw;
int32 __CFUNC     DAQmxWriteRaw                (TaskHandle taskHandle, int32 numSamps, bool32 autoStart, float64 timeout, const void *writeArray, int32 *sampsPerChanWritten, bool32 *reserved);

%rename(GetWriteAttribute) DAQmxGetWriteAttribute;
int32 __CFUNC_C   DAQmxGetWriteAttribute       (TaskHandle taskHandle, int32 attribute, void *value, ...);
%rename(SetWriteAttribute) DAQmxSetWriteAttribute;
int32 __CFUNC_C   DAQmxSetWriteAttribute       (TaskHandle taskHandle, int32 attribute, ...);
%rename(ResetWriteAttribute) DAQmxResetWriteAttribute;
int32 __CFUNC     DAQmxResetWriteAttribute     (TaskHandle taskHandle, int32 attribute);



/* NI-DAQmx Specific Attribute Get/Set/Reset Function Declarations
 */
/*** Set/Get functions for DAQmx_CO_CtrTimebaseActiveEdge Uses value
 *** set Edge1
 ***/
%rename(GetCOCtrTimebaseActiveEdge) DAQmxGetCOCtrTimebaseActiveEdge;
int32 __CFUNC DAQmxGetCOCtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCOCtrTimebaseActiveEdge) DAQmxSetCOCtrTimebaseActiveEdge;
int32 __CFUNC DAQmxSetCOCtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCOCtrTimebaseActiveEdge) DAQmxResetCOCtrTimebaseActiveEdge;
int32 __CFUNC DAQmxResetCOCtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_Src
 ***/
%rename(GetSampClkSrc) DAQmxGetSampClkSrc;
int32 __CFUNC DAQmxGetSampClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetSampClkSrc) DAQmxSetSampClkSrc;
int32 __CFUNC DAQmxSetSampClkSrc(TaskHandle taskHandle, const char *data);
%rename(ResetSampClkSrc) DAQmxResetSampClkSrc;
int32 __CFUNC DAQmxResetSampClkSrc(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_Exported_AIHoldCmpltEvent_PulsePolarity Uses value set
 *** Polarity2
 ***/
%rename(GetExportedAIHoldCmpltEventPulsePolarity) DAQmxGetExportedAIHoldCmpltEventPulsePolarity;
int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedAIHoldCmpltEventPulsePolarity) DAQmxSetExportedAIHoldCmpltEventPulsePolarity;
int32 __CFUNC DAQmxSetExportedAIHoldCmpltEventPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedAIHoldCmpltEventPulsePolarity) DAQmxResetExportedAIHoldCmpltEventPulsePolarity;
int32 __CFUNC DAQmxResetExportedAIHoldCmpltEventPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AO_Gains
 ***/
%rename(GetDevAOGains) DAQmxGetDevAOGains;
int32 __CFUNC DAQmxGetDevAOGains(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_CO_PulseDone
 ***/
%rename(GetCOPulseDone) DAQmxGetCOPulseDone;
int32 __CFUNC DAQmxGetCOPulseDone(TaskHandle taskHandle, const char channel[], bool32 *data);
/*** Set/Get functions for DAQmx_Dev_DI_MaxRate
 ***/
%rename(GetDevDIMaxRate) DAQmxGetDevDIMaxRate;
int32 __CFUNC DAQmxGetDevDIMaxRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_AO_Max
 ***/
%rename(GetAOMax) DAQmxGetAOMax;
int32 __CFUNC DAQmxGetAOMax(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOMax) DAQmxSetAOMax;
int32 __CFUNC DAQmxSetAOMax(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOMax) DAQmxResetAOMax;
int32 __CFUNC DAQmxResetAOMax(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_Exported_HshkEvent_Interlocked_AssertOnStart
 ***/
%rename(GetExportedHshkEventInterlockedAssertOnStart) DAQmxGetExportedHshkEventInterlockedAssertOnStart;
int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertOnStart(TaskHandle taskHandle, bool32 *data);
%rename(SetExportedHshkEventInterlockedAssertOnStart) DAQmxSetExportedHshkEventInterlockedAssertOnStart;
int32 __CFUNC DAQmxSetExportedHshkEventInterlockedAssertOnStart(TaskHandle taskHandle, bool32 data);
%rename(ResetExportedHshkEventInterlockedAssertOnStart) DAQmxResetExportedHshkEventInterlockedAssertOnStart;
int32 __CFUNC DAQmxResetExportedHshkEventInterlockedAssertOnStart(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_CI_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevCITrigUsage) DAQmxGetDevCITrigUsage;
int32 __CFUNC DAQmxGetDevCITrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_AO_DevScalingCoeff
 ***/
%rename(GetAODevScalingCoeff) DAQmxGetAODevScalingCoeff;
int32 __CFUNC DAQmxGetAODevScalingCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_DigEdge_StartTrig_DigSync_Enable
 ***/
%rename(GetDigEdgeStartTrigDigSyncEnable) DAQmxGetDigEdgeStartTrigDigSyncEnable;
int32 __CFUNC DAQmxGetDigEdgeStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigEdgeStartTrigDigSyncEnable) DAQmxSetDigEdgeStartTrigDigSyncEnable;
int32 __CFUNC DAQmxSetDigEdgeStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigEdgeStartTrigDigSyncEnable) DAQmxResetDigEdgeStartTrigDigSyncEnable;
int32 __CFUNC DAQmxResetDigEdgeStartTrigDigSyncEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_CurrentRngs
 ***/
%rename(GetDevAICurrentRngs) DAQmxGetDevAICurrentRngs;
int32 __CFUNC DAQmxGetDevAICurrentRngs(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_Hshk_StartCond Uses value set
 *** HandshakeStartCondition
 ***/
%rename(GetHshkStartCond) DAQmxGetHshkStartCond;
int32 __CFUNC DAQmxGetHshkStartCond(TaskHandle taskHandle, int32 *data);
%rename(SetHshkStartCond) DAQmxSetHshkStartCond;
int32 __CFUNC DAQmxSetHshkStartCond(TaskHandle taskHandle, int32 data);
%rename(ResetHshkStartCond) DAQmxResetHshkStartCond;
int32 __CFUNC DAQmxResetHshkStartCond(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_Second_DigFltr_Enable
 ***/
%rename(GetCITwoEdgeSepSecondDigFltrEnable) DAQmxGetCITwoEdgeSepSecondDigFltrEnable;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCITwoEdgeSepSecondDigFltrEnable) DAQmxSetCITwoEdgeSepSecondDigFltrEnable;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCITwoEdgeSepSecondDigFltrEnable) DAQmxResetCITwoEdgeSepSecondDigFltrEnable;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_LineStates_StartState Uses value
 *** set DigitalLineState
 ***/
%rename(GetDOLineStatesStartState) DAQmxGetDOLineStatesStartState;
int32 __CFUNC DAQmxGetDOLineStatesStartState(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOLineStatesStartState) DAQmxSetDOLineStatesStartState;
int32 __CFUNC DAQmxSetDOLineStatesStartState(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOLineStatesStartState) DAQmxResetDOLineStatesStartState;
int32 __CFUNC DAQmxResetDOLineStatesStartState(TaskHandle taskHandle, const char channel[]);
/*** Device Set/Get functions for DAQmx_Dev_IsSimulated
 ***/
%rename(GetDevIsSimulated) DAQmxGetDevIsSimulated;
int32 __CFUNC DAQmxGetDevIsSimulated(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_DO_Overcurrent_AutoReenable
 ***/
%rename(GetDOOvercurrentAutoReenable) DAQmxGetDOOvercurrentAutoReenable;
int32 __CFUNC DAQmxGetDOOvercurrentAutoReenable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDOOvercurrentAutoReenable) DAQmxSetDOOvercurrentAutoReenable;
int32 __CFUNC DAQmxSetDOOvercurrentAutoReenable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDOOvercurrentAutoReenable) DAQmxResetDOOvercurrentAutoReenable;
int32 __CFUNC DAQmxResetDOOvercurrentAutoReenable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_CustomScaleName
 ***/
%rename(GetAOCustomScaleName) DAQmxGetAOCustomScaleName;
int32 __CFUNC DAQmxGetAOCustomScaleName(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAOCustomScaleName) DAQmxSetAOCustomScaleName;
int32 __CFUNC DAQmxSetAOCustomScaleName(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAOCustomScaleName) DAQmxResetAOCustomScaleName;
int32 __CFUNC DAQmxResetAOCustomScaleName(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_DCOffset
 ***/
%rename(GetAIDCOffset) DAQmxGetAIDCOffset;
int32 __CFUNC DAQmxGetAIDCOffset(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIDCOffset) DAQmxSetAIDCOffset;
int32 __CFUNC DAQmxSetAIDCOffset(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIDCOffset) DAQmxResetAIDCOffset;
int32 __CFUNC DAQmxResetAIDCOffset(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_DigTrigSupported
 ***/
%rename(GetDevDigTrigSupported) DAQmxGetDevDigTrigSupported;
int32 __CFUNC DAQmxGetDevDigTrigSupported(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_CI_Freq_StartingEdge Uses value set
 *** Edge1
 ***/
%rename(GetCIFreqStartingEdge) DAQmxGetCIFreqStartingEdge;
int32 __CFUNC DAQmxGetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIFreqStartingEdge) DAQmxSetCIFreqStartingEdge;
int32 __CFUNC DAQmxSetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIFreqStartingEdge) DAQmxResetCIFreqStartingEdge;
int32 __CFUNC DAQmxResetCIFreqStartingEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_Settled
 ***/
%rename(GetSwitchDevSettled) DAQmxGetSwitchDevSettled;
int32 __CFUNC DAQmxGetSwitchDevSettled(const char deviceName[], bool32 *data);
/*** Set/Get functions for DAQmx_Read_NumChans
 ***/
%rename(GetReadNumChans) DAQmxGetReadNumChans;
int32 __CFUNC DAQmxGetReadNumChans(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_AO_Resolution
 ***/
%rename(GetAOResolution) DAQmxGetAOResolution;
int32 __CFUNC DAQmxGetAOResolution(TaskHandle taskHandle, const char channel[], float64 *data);
/*** Set/Get functions for DAQmx_AO_FuncGen_Type Uses value set
 *** FuncGenType
 ***/
%rename(GetAOFuncGenType) DAQmxGetAOFuncGenType;
int32 __CFUNC DAQmxGetAOFuncGenType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOFuncGenType) DAQmxSetAOFuncGenType;
int32 __CFUNC DAQmxSetAOFuncGenType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOFuncGenType) DAQmxResetAOFuncGenType;
int32 __CFUNC DAQmxResetAOFuncGenType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigPattern_RefTrig_When Uses value
 *** set DigitalPatternCondition1
 ***/
%rename(GetDigPatternRefTrigWhen) DAQmxGetDigPatternRefTrigWhen;
int32 __CFUNC DAQmxGetDigPatternRefTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetDigPatternRefTrigWhen) DAQmxSetDigPatternRefTrigWhen;
int32 __CFUNC DAQmxSetDigPatternRefTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetDigPatternRefTrigWhen) DAQmxResetDigPatternRefTrigWhen;
int32 __CFUNC DAQmxResetDigPatternRefTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Count
 ***/
%rename(GetCICount) DAQmxGetCICount;
int32 __CFUNC DAQmxGetCICount(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_CountEdges_DigFltr_TimebaseRate
 ***/
%rename(GetCICountEdgesDigFltrTimebaseRate) DAQmxGetCICountEdgesDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCICountEdgesDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICountEdgesDigFltrTimebaseRate) DAQmxSetCICountEdgesDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCICountEdgesDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICountEdgesDigFltrTimebaseRate) DAQmxResetCICountEdgesDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ACExcit_WireMode Uses value set
 *** ACExcitWireMode
 ***/
%rename(GetAIACExcitWireMode) DAQmxGetAIACExcitWireMode;
int32 __CFUNC DAQmxGetAIACExcitWireMode(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIACExcitWireMode) DAQmxSetAIACExcitWireMode;
int32 __CFUNC DAQmxSetAIACExcitWireMode(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIACExcitWireMode) DAQmxResetAIACExcitWireMode;
int32 __CFUNC DAQmxResetAIACExcitWireMode(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_CountEdges_CountDir_DigFltr_TimebaseSrc
 ***/
%rename(GetCICountEdgesCountDirDigFltrTimebaseSrc) DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICountEdgesCountDirDigFltrTimebaseSrc) DAQmxSetCICountEdgesCountDirDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCICountEdgesCountDirDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICountEdgesCountDirDigFltrTimebaseSrc) DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Impedance Uses value set
 *** Impedance1
 ***/
%rename(GetAIImpedance) DAQmxGetAIImpedance;
int32 __CFUNC DAQmxGetAIImpedance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIImpedance) DAQmxSetAIImpedance;
int32 __CFUNC DAQmxSetAIImpedance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIImpedance) DAQmxResetAIImpedance;
int32 __CFUNC DAQmxResetAIImpedance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_FuncGen_Offset
 ***/
%rename(GetAOFuncGenOffset) DAQmxGetAOFuncGenOffset;
int32 __CFUNC DAQmxGetAOFuncGenOffset(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOFuncGenOffset) DAQmxSetAOFuncGenOffset;
int32 __CFUNC DAQmxSetAOFuncGenOffset(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOFuncGenOffset) DAQmxResetAOFuncGenOffset;
int32 __CFUNC DAQmxResetAOFuncGenOffset(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_Topology
 ***/
%rename(GetSwitchDevTopology) DAQmxGetSwitchDevTopology;
int32 __CFUNC DAQmxGetSwitchDevTopology(const char deviceName[], char *data, uInt32 bufferSize);

/*** Set/Get functions for DAQmx_SwitchChan_MaxDCSwitchPwr
 ***/
%rename(GetSwitchChanMaxDCSwitchPwr) DAQmxGetSwitchChanMaxDCSwitchPwr;
int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchPwr(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_RTD_A
 ***/
%rename(GetAIRTDA) DAQmxGetAIRTDA;
int32 __CFUNC DAQmxGetAIRTDA(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRTDA) DAQmxSetAIRTDA;
int32 __CFUNC DAQmxSetAIRTDA(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRTDA) DAQmxResetAIRTDA;
int32 __CFUNC DAQmxResetAIRTDA(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_CtrTimebase_DigFltr_Enable
 ***/
%rename(GetCOCtrTimebaseDigFltrEnable) DAQmxGetCOCtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCOCtrTimebaseDigFltrEnable) DAQmxSetCOCtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxSetCOCtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCOCtrTimebaseDigFltrEnable) DAQmxResetCOCtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_LossyLSBRemoval_CompressedSampSize
 ***/
%rename(GetAILossyLSBRemovalCompressedSampSize) DAQmxGetAILossyLSBRemovalCompressedSampSize;
int32 __CFUNC DAQmxGetAILossyLSBRemovalCompressedSampSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAILossyLSBRemovalCompressedSampSize) DAQmxSetAILossyLSBRemovalCompressedSampSize;
int32 __CFUNC DAQmxSetAILossyLSBRemovalCompressedSampSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAILossyLSBRemovalCompressedSampSize) DAQmxResetAILossyLSBRemovalCompressedSampSize;
int32 __CFUNC DAQmxResetAILossyLSBRemovalCompressedSampSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_RTD_B
 ***/
%rename(GetAIRTDB) DAQmxGetAIRTDB;
int32 __CFUNC DAQmxGetAIRTDB(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRTDB) DAQmxSetAIRTDB;
int32 __CFUNC DAQmxSetAIRTDB(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRTDB) DAQmxResetAIRTDB;
int32 __CFUNC DAQmxResetAIRTDB(TaskHandle taskHandle, const char channel[]);
/*** Switch Device Set/Get functions for DAQmx_SwitchDev_SettlingTime
 ***/
%rename(GetSwitchDevSettlingTime) DAQmxGetSwitchDevSettlingTime;
int32 __CFUNC DAQmxGetSwitchDevSettlingTime(const char deviceName[], float64 *data);
%rename(SetSwitchDevSettlingTime) DAQmxSetSwitchDevSettlingTime;
int32 __CFUNC DAQmxSetSwitchDevSettlingTime(const char deviceName[], float64 data);
/*** Set/Get functions for DAQmx_Dev_CI_PhysicalChans
 ***/
%rename(GetDevCIPhysicalChans) DAQmxGetDevCIPhysicalChans;
int32 __CFUNC DAQmxGetDevCIPhysicalChans(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CO_CtrTimebaseRate
 ***/
%rename(GetCOCtrTimebaseRate) DAQmxGetCOCtrTimebaseRate;
int32 __CFUNC DAQmxGetCOCtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOCtrTimebaseRate) DAQmxSetCOCtrTimebaseRate;
int32 __CFUNC DAQmxSetCOCtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOCtrTimebaseRate) DAQmxResetCOCtrTimebaseRate;
int32 __CFUNC DAQmxResetCOCtrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_NumColumns
 ***/
%rename(GetSwitchDevNumColumns) DAQmxGetSwitchDevNumColumns;
int32 __CFUNC DAQmxGetSwitchDevNumColumns(const char deviceName[], uInt32 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_ScaleType Uses value set
 *** ScaleType3
 ***/
%rename(GetAIChanCalScaleType) DAQmxGetAIChanCalScaleType;
int32 __CFUNC DAQmxGetAIChanCalScaleType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIChanCalScaleType) DAQmxSetAIChanCalScaleType;
int32 __CFUNC DAQmxSetAIChanCalScaleType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIChanCalScaleType) DAQmxResetAIChanCalScaleType;
int32 __CFUNC DAQmxResetAIChanCalScaleType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_SampClk_OutputBehavior Uses
 *** value set ExportActions3
 ***/
%rename(GetExportedSampClkOutputBehavior) DAQmxGetExportedSampClkOutputBehavior;
int32 __CFUNC DAQmxGetExportedSampClkOutputBehavior(TaskHandle taskHandle, int32 *data);
%rename(SetExportedSampClkOutputBehavior) DAQmxSetExportedSampClkOutputBehavior;
int32 __CFUNC DAQmxSetExportedSampClkOutputBehavior(TaskHandle taskHandle, int32 data);
%rename(ResetExportedSampClkOutputBehavior) DAQmxResetExportedSampClkOutputBehavior;
int32 __CFUNC DAQmxResetExportedSampClkOutputBehavior(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_OvercurrentChans
 ***/
%rename(GetReadOvercurrentChans) DAQmxGetReadOvercurrentChans;
int32 __CFUNC DAQmxGetReadOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AIConv_MaxRate
 ***/
%rename(GetAIConvMaxRate) DAQmxGetAIConvMaxRate;
int32 __CFUNC DAQmxGetAIConvMaxRate(TaskHandle taskHandle, float64 *data);
%rename(GetAIConvMaxRateEx) DAQmxGetAIConvMaxRateEx;
int32 __CFUNC DAQmxGetAIConvMaxRateEx(TaskHandle taskHandle, const char deviceNames[], float64 *data);
/*** Set/Get functions for DAQmx_Hshk_SampleInputDataWhen Uses value
 *** set SampleInputDataWhen
 ***/
%rename(GetHshkSampleInputDataWhen) DAQmxGetHshkSampleInputDataWhen;
int32 __CFUNC DAQmxGetHshkSampleInputDataWhen(TaskHandle taskHandle, int32 *data);
%rename(SetHshkSampleInputDataWhen) DAQmxSetHshkSampleInputDataWhen;
int32 __CFUNC DAQmxSetHshkSampleInputDataWhen(TaskHandle taskHandle, int32 data);
%rename(ResetHshkSampleInputDataWhen) DAQmxResetHshkSampleInputDataWhen;
int32 __CFUNC DAQmxResetHshkSampleInputDataWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_PersistedChan_AllowInteractiveEditing
 ***/
%rename(GetPersistedChanAllowInteractiveEditing) DAQmxGetPersistedChanAllowInteractiveEditing;
int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveEditing(const char channel[], bool32 *data);
/*** Set/Get functions for DAQmx_AI_Temp_Units Uses value set
 *** TemperatureUnits1
 ***/
%rename(GetAITempUnits) DAQmxGetAITempUnits;
int32 __CFUNC DAQmxGetAITempUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAITempUnits) DAQmxSetAITempUnits;
int32 __CFUNC DAQmxSetAITempUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAITempUnits) DAQmxResetAITempUnits;
int32 __CFUNC DAQmxResetAITempUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_OnDemand_SimultaneousAOEnable
 ***/
%rename(GetOnDemandSimultaneousAOEnable) DAQmxGetOnDemandSimultaneousAOEnable;
int32 __CFUNC DAQmxGetOnDemandSimultaneousAOEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetOnDemandSimultaneousAOEnable) DAQmxSetOnDemandSimultaneousAOEnable;
int32 __CFUNC DAQmxSetOnDemandSimultaneousAOEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetOnDemandSimultaneousAOEnable) DAQmxResetOnDemandSimultaneousAOEnable;
int32 __CFUNC DAQmxResetOnDemandSimultaneousAOEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_Pulse_Freq_Units Uses value set
 *** FrequencyUnits2
 ***/
%rename(GetCOPulseFreqUnits) DAQmxGetCOPulseFreqUnits;
int32 __CFUNC DAQmxGetCOPulseFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCOPulseFreqUnits) DAQmxSetCOPulseFreqUnits;
int32 __CFUNC DAQmxSetCOPulseFreqUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCOPulseFreqUnits) DAQmxResetCOPulseFreqUnits;
int32 __CFUNC DAQmxResetCOPulseFreqUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Prescaler
 ***/
%rename(GetCOPrescaler) DAQmxGetCOPrescaler;
int32 __CFUNC DAQmxGetCOPrescaler(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOPrescaler) DAQmxSetCOPrescaler;
int32 __CFUNC DAQmxSetCOPrescaler(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOPrescaler) DAQmxResetCOPrescaler;
int32 __CFUNC DAQmxResetCOPrescaler(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_DO_Ports
 ***/
%rename(GetDevDOPorts) DAQmxGetDevDOPorts;
int32 __CFUNC DAQmxGetDevDOPorts(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AO_ResolutionUnits Uses value set
 *** ResolutionType1
 ***/
%rename(GetAOResolutionUnits) DAQmxGetAOResolutionUnits;
int32 __CFUNC DAQmxGetAOResolutionUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOResolutionUnits) DAQmxSetAOResolutionUnits;
int32 __CFUNC DAQmxSetAOResolutionUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOResolutionUnits) DAQmxResetAOResolutionUnits;
int32 __CFUNC DAQmxResetAOResolutionUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_PCI_DevNum
 ***/
%rename(GetDevPCIDevNum) DAQmxGetDevPCIDevNum;
int32 __CFUNC DAQmxGetDevPCIDevNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_CustomScaleName
 ***/
%rename(GetCICustomScaleName) DAQmxGetCICustomScaleName;
int32 __CFUNC DAQmxGetCICustomScaleName(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICustomScaleName) DAQmxSetCICustomScaleName;
int32 __CFUNC DAQmxSetCICustomScaleName(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICustomScaleName) DAQmxResetCICustomScaleName;
int32 __CFUNC DAQmxResetCICustomScaleName(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Freq_Div
 ***/
%rename(GetCIFreqDiv) DAQmxGetCIFreqDiv;
int32 __CFUNC DAQmxGetCIFreqDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCIFreqDiv) DAQmxSetCIFreqDiv;
int32 __CFUNC DAQmxSetCIFreqDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCIFreqDiv) DAQmxResetCIFreqDiv;
int32 __CFUNC DAQmxResetCIFreqDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ChanCal_OperatorName
 ***/
%rename(GetAIChanCalOperatorName) DAQmxGetAIChanCalOperatorName;
int32 __CFUNC DAQmxGetAIChanCalOperatorName(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAIChanCalOperatorName) DAQmxSetAIChanCalOperatorName;
int32 __CFUNC DAQmxSetAIChanCalOperatorName(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAIChanCalOperatorName) DAQmxResetAIChanCalOperatorName;
int32 __CFUNC DAQmxResetAIChanCalOperatorName(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchScan_WaitingForAdv
 ***/
%rename(GetSwitchScanWaitingForAdv) DAQmxGetSwitchScanWaitingForAdv;
int32 __CFUNC DAQmxGetSwitchScanWaitingForAdv(TaskHandle taskHandle, bool32 *data);

/*** Set/Get functions for DAQmx_AI_Lowpass_SwitchCap_OutClkDiv
 ***/
%rename(GetAILowpassSwitchCapOutClkDiv) DAQmxGetAILowpassSwitchCapOutClkDiv;
int32 __CFUNC DAQmxGetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAILowpassSwitchCapOutClkDiv) DAQmxSetAILowpassSwitchCapOutClkDiv;
int32 __CFUNC DAQmxSetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAILowpassSwitchCapOutClkDiv) DAQmxResetAILowpassSwitchCapOutClkDiv;
int32 __CFUNC DAQmxResetAILowpassSwitchCapOutClkDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_PauseTrig_Coupling Uses value
 *** set Coupling2
 ***/
%rename(GetAnlgWinPauseTrigCoupling) DAQmxGetAnlgWinPauseTrigCoupling;
int32 __CFUNC DAQmxGetAnlgWinPauseTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinPauseTrigCoupling) DAQmxSetAnlgWinPauseTrigCoupling;
int32 __CFUNC DAQmxSetAnlgWinPauseTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinPauseTrigCoupling) DAQmxResetAnlgWinPauseTrigCoupling;
int32 __CFUNC DAQmxResetAnlgWinPauseTrigCoupling(TaskHandle taskHandle);
/*** Persisted Channel Set/Get functions for
 *** DAQmx_PersistedChan_Author
 ***/
%rename(GetPersistedChanAuthor) DAQmxGetPersistedChanAuthor;
int32 __CFUNC DAQmxGetPersistedChanAuthor(const char channel[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CI_OutputState Uses value set Level1
 ***/
%rename(GetCIOutputState) DAQmxGetCIOutputState;
int32 __CFUNC DAQmxGetCIOutputState(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_CI_GPS_SyncMethod Uses value set
 *** GpsSignalType1
 ***/
%rename(GetCIGPSSyncMethod) DAQmxGetCIGPSSyncMethod;
int32 __CFUNC DAQmxGetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIGPSSyncMethod) DAQmxSetCIGPSSyncMethod;
int32 __CFUNC DAQmxSetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIGPSSyncMethod) DAQmxResetCIGPSSyncMethod;
int32 __CFUNC DAQmxResetCIGPSSyncMethod(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_DigFltr_Enable
 ***/
%rename(GetDigLvlPauseTrigDigFltrEnable) DAQmxGetDigLvlPauseTrigDigFltrEnable;
int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigLvlPauseTrigDigFltrEnable) DAQmxSetDigLvlPauseTrigDigFltrEnable;
int32 __CFUNC DAQmxSetDigLvlPauseTrigDigFltrEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigLvlPauseTrigDigFltrEnable) DAQmxResetDigLvlPauseTrigDigFltrEnable;
int32 __CFUNC DAQmxResetDigLvlPauseTrigDigFltrEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_LinEncoder_DistPerPulse
 ***/
%rename(GetCILinEncoderDistPerPulse) DAQmxGetCILinEncoderDistPerPulse;
int32 __CFUNC DAQmxGetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCILinEncoderDistPerPulse) DAQmxSetCILinEncoderDistPerPulse;
int32 __CFUNC DAQmxSetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCILinEncoderDistPerPulse) DAQmxResetCILinEncoderDistPerPulse;
int32 __CFUNC DAQmxResetCILinEncoderDistPerPulse(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchChan_MaxACCarryCurrent
 ***/
%rename(GetSwitchChanMaxACCarryCurrent) DAQmxGetSwitchChanMaxACCarryCurrent;
int32 __CFUNC DAQmxGetSwitchChanMaxACCarryCurrent(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_EnableCal
 ***/
%rename(GetAIChanCalEnableCal) DAQmxGetAIChanCalEnableCal;
int32 __CFUNC DAQmxGetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIChanCalEnableCal) DAQmxSetAIChanCalEnableCal;
int32 __CFUNC DAQmxSetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIChanCalEnableCal) DAQmxResetAIChanCalEnableCal;
int32 __CFUNC DAQmxResetAIChanCalEnableCal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ResolutionUnits Uses value set
 *** ResolutionType1
 ***/
%rename(GetAIResolutionUnits) DAQmxGetAIResolutionUnits;
int32 __CFUNC DAQmxGetAIResolutionUnits(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_AI_ACExcit_SyncEnable
 ***/
%rename(GetAIACExcitSyncEnable) DAQmxGetAIACExcitSyncEnable;
int32 __CFUNC DAQmxGetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIACExcitSyncEnable) DAQmxSetAIACExcitSyncEnable;
int32 __CFUNC DAQmxSetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIACExcitSyncEnable) DAQmxResetAIACExcitSyncEnable;
int32 __CFUNC DAQmxResetAIACExcitSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Thrmcpl_CJCChan
 ***/
%rename(GetAIThrmcplCJCChan) DAQmxGetAIThrmcplCJCChan;
int32 __CFUNC DAQmxGetAIThrmcplCJCChan(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CO_CtrTimebase_DigFltr_MinPulseWidth
 ***/
%rename(GetCOCtrTimebaseDigFltrMinPulseWidth) DAQmxGetCOCtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOCtrTimebaseDigFltrMinPulseWidth) DAQmxSetCOCtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCOCtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOCtrTimebaseDigFltrMinPulseWidth) DAQmxResetCOCtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_PXI_ChassisNum
 ***/
%rename(GetDevPXIChassisNum) DAQmxGetDevPXIChassisNum;
int32 __CFUNC DAQmxGetDevPXIChassisNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_Units Uses value set
 *** TimeUnits3
 ***/
%rename(GetCITwoEdgeSepUnits) DAQmxGetCITwoEdgeSepUnits;
int32 __CFUNC DAQmxGetCITwoEdgeSepUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCITwoEdgeSepUnits) DAQmxSetCITwoEdgeSepUnits;
int32 __CFUNC DAQmxSetCITwoEdgeSepUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCITwoEdgeSepUnits) DAQmxResetCITwoEdgeSepUnits;
int32 __CFUNC DAQmxResetCITwoEdgeSepUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Interlocked_HshkTrig_Src
 ***/
%rename(GetInterlockedHshkTrigSrc) DAQmxGetInterlockedHshkTrigSrc;
int32 __CFUNC DAQmxGetInterlockedHshkTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetInterlockedHshkTrigSrc) DAQmxSetInterlockedHshkTrigSrc;
int32 __CFUNC DAQmxSetInterlockedHshkTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetInterlockedHshkTrigSrc) DAQmxResetInterlockedHshkTrigSrc;
int32 __CFUNC DAQmxResetInterlockedHshkTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_ResistanceCfg Uses value set
 *** ResistanceConfiguration
 ***/
%rename(GetAIResistanceCfg) DAQmxGetAIResistanceCfg;
int32 __CFUNC DAQmxGetAIResistanceCfg(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIResistanceCfg) DAQmxSetAIResistanceCfg;
int32 __CFUNC DAQmxSetAIResistanceCfg(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIResistanceCfg) DAQmxResetAIResistanceCfg;
int32 __CFUNC DAQmxResetAIResistanceCfg(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_SerialNum
 ***/
%rename(GetPhysicalChanTEDSSerialNum) DAQmxGetPhysicalChanTEDSSerialNum;
int32 __CFUNC DAQmxGetPhysicalChanTEDSSerialNum(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_DelayFromSampClk_Delay
 ***/
%rename(GetDelayFromSampClkDelay) DAQmxGetDelayFromSampClkDelay;
int32 __CFUNC DAQmxGetDelayFromSampClkDelay(TaskHandle taskHandle, float64 *data);
%rename(SetDelayFromSampClkDelay) DAQmxSetDelayFromSampClkDelay;
int32 __CFUNC DAQmxSetDelayFromSampClkDelay(TaskHandle taskHandle, float64 data);
%rename(ResetDelayFromSampClkDelay) DAQmxResetDelayFromSampClkDelay;
int32 __CFUNC DAQmxResetDelayFromSampClkDelay(TaskHandle taskHandle);
%rename(GetDelayFromSampClkDelayEx) DAQmxGetDelayFromSampClkDelayEx;
int32 __CFUNC DAQmxGetDelayFromSampClkDelayEx(TaskHandle taskHandle, const char deviceNames[], float64 *data);
%rename(SetDelayFromSampClkDelayEx) DAQmxSetDelayFromSampClkDelayEx;
int32 __CFUNC DAQmxSetDelayFromSampClkDelayEx(TaskHandle taskHandle, const char deviceNames[], float64 data);
%rename(ResetDelayFromSampClkDelayEx) DAQmxResetDelayFromSampClkDelayEx;
int32 __CFUNC DAQmxResetDelayFromSampClkDelayEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_AI_Freq_Hyst
 ***/
%rename(GetAIFreqHyst) DAQmxGetAIFreqHyst;
int32 __CFUNC DAQmxGetAIFreqHyst(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIFreqHyst) DAQmxSetAIFreqHyst;
int32 __CFUNC DAQmxSetAIFreqHyst(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIFreqHyst) DAQmxResetAIFreqHyst;
int32 __CFUNC DAQmxResetAIFreqHyst(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_ChangeDetect_DI_RisingEdgePhysicalChans
 ***/
%rename(GetChangeDetectDIRisingEdgePhysicalChans) DAQmxGetChangeDetectDIRisingEdgePhysicalChans;
int32 __CFUNC DAQmxGetChangeDetectDIRisingEdgePhysicalChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetChangeDetectDIRisingEdgePhysicalChans) DAQmxSetChangeDetectDIRisingEdgePhysicalChans;
int32 __CFUNC DAQmxSetChangeDetectDIRisingEdgePhysicalChans(TaskHandle taskHandle, const char *data);
%rename(ResetChangeDetectDIRisingEdgePhysicalChans) DAQmxResetChangeDetectDIRisingEdgePhysicalChans;
int32 __CFUNC DAQmxResetChangeDetectDIRisingEdgePhysicalChans(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SyncPulse_Src
 ***/
%rename(GetSyncPulseSrc) DAQmxGetSyncPulseSrc;
int32 __CFUNC DAQmxGetSyncPulseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetSyncPulseSrc) DAQmxSetSyncPulseSrc;
int32 __CFUNC DAQmxSetSyncPulseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetSyncPulseSrc) DAQmxResetSyncPulseSrc;
int32 __CFUNC DAQmxResetSyncPulseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_Term
 ***/
%rename(GetCISemiPeriodTerm) DAQmxGetCISemiPeriodTerm;
int32 __CFUNC DAQmxGetCISemiPeriodTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCISemiPeriodTerm) DAQmxSetCISemiPeriodTerm;
int32 __CFUNC DAQmxSetCISemiPeriodTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCISemiPeriodTerm) DAQmxResetCISemiPeriodTerm;
int32 __CFUNC DAQmxResetCISemiPeriodTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Sys_Scales
 ***/
%rename(GetSysScales) DAQmxGetSysScales;
int32 __CFUNC DAQmxGetSysScales(char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AI_ChanCal_Table_PreScaledVals
 ***/
%rename(GetAIChanCalTablePreScaledVals) DAQmxGetAIChanCalTablePreScaledVals;
int32 __CFUNC DAQmxGetAIChanCalTablePreScaledVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalTablePreScaledVals) DAQmxSetAIChanCalTablePreScaledVals;
int32 __CFUNC DAQmxSetAIChanCalTablePreScaledVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalTablePreScaledVals) DAQmxResetAIChanCalTablePreScaledVals;
int32 __CFUNC DAQmxResetAIChanCalTablePreScaledVals(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Watchdog_HasExpired
 ***/
%rename(GetWatchdogHasExpired) DAQmxGetWatchdogHasExpired;
int32 __CFUNC DAQmxGetWatchdogHasExpired(TaskHandle taskHandle, bool32 *data);

/*** Set/Get functions for DAQmx_CI_Period_DigFltr_Enable
 ***/
%rename(GetCIPeriodDigFltrEnable) DAQmxGetCIPeriodDigFltrEnable;
int32 __CFUNC DAQmxGetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIPeriodDigFltrEnable) DAQmxSetCIPeriodDigFltrEnable;
int32 __CFUNC DAQmxSetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIPeriodDigFltrEnable) DAQmxResetCIPeriodDigFltrEnable;
int32 __CFUNC DAQmxResetCIPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_VersionLetter
 ***/
%rename(GetPhysicalChanTEDSVersionLetter) DAQmxGetPhysicalChanTEDSVersionLetter;
int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionLetter(const char physicalChannel[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Read_AvailSampPerChan
 ***/
%rename(GetReadAvailSampPerChan) DAQmxGetReadAvailSampPerChan;
int32 __CFUNC DAQmxGetReadAvailSampPerChan(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_AO_Voltage_Units Uses value set
 *** VoltageUnits2
 ***/
%rename(GetAOVoltageUnits) DAQmxGetAOVoltageUnits;
int32 __CFUNC DAQmxGetAOVoltageUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOVoltageUnits) DAQmxSetAOVoltageUnits;
int32 __CFUNC DAQmxSetAOVoltageUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOVoltageUnits) DAQmxResetAOVoltageUnits;
int32 __CFUNC DAQmxResetAOVoltageUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AO_PhysicalChans
 ***/
%rename(GetDevAOPhysicalChans) DAQmxGetDevAOPhysicalChans;
int32 __CFUNC DAQmxGetDevAOPhysicalChans(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Dev_CO_MaxTimebase
 ***/
%rename(GetDevCOMaxTimebase) DAQmxGetDevCOMaxTimebase;
int32 __CFUNC DAQmxGetDevCOMaxTimebase(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_When Uses value set
 *** Level1
 ***/
%rename(GetDigLvlPauseTrigWhen) DAQmxGetDigLvlPauseTrigWhen;
int32 __CFUNC DAQmxGetDigLvlPauseTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetDigLvlPauseTrigWhen) DAQmxSetDigLvlPauseTrigWhen;
int32 __CFUNC DAQmxSetDigLvlPauseTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetDigLvlPauseTrigWhen) DAQmxResetDigLvlPauseTrigWhen;
int32 __CFUNC DAQmxResetDigLvlPauseTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Sys_NIDAQMinorVersion
 ***/
%rename(GetSysNIDAQMinorVersion) DAQmxGetSysNIDAQMinorVersion;
int32 __CFUNC DAQmxGetSysNIDAQMinorVersion(uInt32 *data);

/*** Set/Get functions for DAQmx_SwitchChan_Bandwidth
 ***/
%rename(GetSwitchChanBandwidth) DAQmxGetSwitchChanBandwidth;
int32 __CFUNC DAQmxGetSwitchChanBandwidth(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_Freq_ThreshVoltage
 ***/
%rename(GetAIFreqThreshVoltage) DAQmxGetAIFreqThreshVoltage;
int32 __CFUNC DAQmxGetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIFreqThreshVoltage) DAQmxSetAIFreqThreshVoltage;
int32 __CFUNC DAQmxSetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIFreqThreshVoltage) DAQmxResetAIFreqThreshVoltage;
int32 __CFUNC DAQmxResetAIFreqThreshVoltage(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Period_DigFltr_TimebaseRate
 ***/
%rename(GetCIPeriodDigFltrTimebaseRate) DAQmxGetCIPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIPeriodDigFltrTimebaseRate) DAQmxSetCIPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIPeriodDigFltrTimebaseRate) DAQmxResetCIPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_HshkEvent_Delay
 ***/
%rename(GetExportedHshkEventDelay) DAQmxGetExportedHshkEventDelay;
int32 __CFUNC DAQmxGetExportedHshkEventDelay(TaskHandle taskHandle, float64 *data);
%rename(SetExportedHshkEventDelay) DAQmxSetExportedHshkEventDelay;
int32 __CFUNC DAQmxSetExportedHshkEventDelay(TaskHandle taskHandle, float64 data);
%rename(ResetExportedHshkEventDelay) DAQmxResetExportedHshkEventDelay;
int32 __CFUNC DAQmxResetExportedHshkEventDelay(TaskHandle taskHandle);
/*** Task Set/Get functions for DAQmx_Task_Name
 ***/
%rename(GetTaskName) DAQmxGetTaskName;
int32 __CFUNC DAQmxGetTaskName(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AI_Dither_Enable
 ***/
%rename(GetAIDitherEnable) DAQmxGetAIDitherEnable;
int32 __CFUNC DAQmxGetAIDitherEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIDitherEnable) DAQmxSetAIDitherEnable;
int32 __CFUNC DAQmxSetAIDitherEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIDitherEnable) DAQmxResetAIDitherEnable;
int32 __CFUNC DAQmxResetAIDitherEnable(TaskHandle taskHandle, const char channel[]);
/*** Persisted Scale Set/Get functions for DAQmx_PersistedScale_Author
 ***/
%rename(GetPersistedScaleAuthor) DAQmxGetPersistedScaleAuthor;
int32 __CFUNC DAQmxGetPersistedScaleAuthor(const char scaleName[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AO_DataXferReqCond Uses value set
 *** OutputDataTransferCondition
 ***/
%rename(GetAODataXferReqCond) DAQmxGetAODataXferReqCond;
int32 __CFUNC DAQmxGetAODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAODataXferReqCond) DAQmxSetAODataXferReqCond;
int32 __CFUNC DAQmxSetAODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAODataXferReqCond) DAQmxResetAODataXferReqCond;
int32 __CFUNC DAQmxResetAODataXferReqCond(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_OutputDriveType Uses value set
 *** DigitalDriveType
 ***/
%rename(GetDOOutputDriveType) DAQmxGetDOOutputDriveType;
int32 __CFUNC DAQmxGetDOOutputDriveType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOOutputDriveType) DAQmxSetDOOutputDriveType;
int32 __CFUNC DAQmxSetDOOutputDriveType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOOutputDriveType) DAQmxResetDOOutputDriveType;
int32 __CFUNC DAQmxResetDOOutputDriveType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_DAC_Ref_Val
 ***/
%rename(GetAODACRefVal) DAQmxGetAODACRefVal;
int32 __CFUNC DAQmxGetAODACRefVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAODACRefVal) DAQmxSetAODACRefVal;
int32 __CFUNC DAQmxSetAODACRefVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAODACRefVal) DAQmxResetAODACRefVal;
int32 __CFUNC DAQmxResetAODACRefVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AnlgTrigSupported
 ***/
%rename(GetDevAnlgTrigSupported) DAQmxGetDevAnlgTrigSupported;
int32 __CFUNC DAQmxGetDevAnlgTrigSupported(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_Cal_UserDefinedInfo
 ***/
%rename(GetCalUserDefinedInfo) DAQmxGetCalUserDefinedInfo;
int32 __CFUNC DAQmxGetCalUserDefinedInfo(const char deviceName[], char *data, uInt32 bufferSize);
%rename(SetCalUserDefinedInfo) DAQmxSetCalUserDefinedInfo;
int32 __CFUNC DAQmxSetCalUserDefinedInfo(const char deviceName[], const char *data);
/*** Set/Get functions for DAQmx_ExtCal_RecommendedInterval
 ***/
%rename(GetExtCalRecommendedInterval) DAQmxGetExtCalRecommendedInterval;
int32 __CFUNC DAQmxGetExtCalRecommendedInterval(const char deviceName[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_SecondEdge Uses value
 *** set Edge1
 ***/
%rename(GetCITwoEdgeSepSecondEdge) DAQmxGetCITwoEdgeSepSecondEdge;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCITwoEdgeSepSecondEdge) DAQmxSetCITwoEdgeSepSecondEdge;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCITwoEdgeSepSecondEdge) DAQmxResetCITwoEdgeSepSecondEdge;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondEdge(TaskHandle taskHandle, const char channel[]);
/*** System Set/Get functions for DAQmx_Sys_GlobalChans
 ***/
%rename(GetSysGlobalChans) DAQmxGetSysGlobalChans;
int32 __CFUNC DAQmxGetSysGlobalChans(char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_DI_NumLines
 ***/
%rename(GetDINumLines) DAQmxGetDINumLines;
int32 __CFUNC DAQmxGetDINumLines(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for DAQmx_AI_Excit_VoltageOrCurrent Uses value
 *** set ExcitationVoltageOrCurrent
 ***/
%rename(GetAIExcitVoltageOrCurrent) DAQmxGetAIExcitVoltageOrCurrent;
int32 __CFUNC DAQmxGetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIExcitVoltageOrCurrent) DAQmxSetAIExcitVoltageOrCurrent;
int32 __CFUNC DAQmxSetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIExcitVoltageOrCurrent) DAQmxResetAIExcitVoltageOrCurrent;
int32 __CFUNC DAQmxResetAIExcitVoltageOrCurrent(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Excit_UseMultiplexed
 ***/
%rename(GetAIExcitUseMultiplexed) DAQmxGetAIExcitUseMultiplexed;
int32 __CFUNC DAQmxGetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIExcitUseMultiplexed) DAQmxSetAIExcitUseMultiplexed;
int32 __CFUNC DAQmxSetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIExcitUseMultiplexed) DAQmxResetAIExcitUseMultiplexed;
int32 __CFUNC DAQmxResetAIExcitUseMultiplexed(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_DI_Ports
 ***/
%rename(GetDevDIPorts) DAQmxGetDevDIPorts;
int32 __CFUNC DAQmxGetDevDIPorts(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AI_EnhancedAliasRejectionEnable
 ***/
%rename(GetAIEnhancedAliasRejectionEnable) DAQmxGetAIEnhancedAliasRejectionEnable;
int32 __CFUNC DAQmxGetAIEnhancedAliasRejectionEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIEnhancedAliasRejectionEnable) DAQmxSetAIEnhancedAliasRejectionEnable;
int32 __CFUNC DAQmxSetAIEnhancedAliasRejectionEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIEnhancedAliasRejectionEnable) DAQmxResetAIEnhancedAliasRejectionEnable;
int32 __CFUNC DAQmxResetAIEnhancedAliasRejectionEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Map_ScaledMin
 ***/
%rename(GetScaleMapScaledMin) DAQmxGetScaleMapScaledMin;
int32 __CFUNC DAQmxGetScaleMapScaledMin(const char scaleName[], float64 *data);
%rename(SetScaleMapScaledMin) DAQmxSetScaleMapScaledMin;
int32 __CFUNC DAQmxSetScaleMapScaledMin(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_AI_Accel_Units Uses value set
 *** AccelUnits2
 ***/
%rename(GetAIAccelUnits) DAQmxGetAIAccelUnits;
int32 __CFUNC DAQmxGetAIAccelUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIAccelUnits) DAQmxSetAIAccelUnits;
int32 __CFUNC DAQmxSetAIAccelUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIAccelUnits) DAQmxResetAIAccelUnits;
int32 __CFUNC DAQmxResetAIAccelUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigPattern_StartTrig_Pattern
 ***/
%rename(GetDigPatternStartTrigPattern) DAQmxGetDigPatternStartTrigPattern;
int32 __CFUNC DAQmxGetDigPatternStartTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternStartTrigPattern) DAQmxSetDigPatternStartTrigPattern;
int32 __CFUNC DAQmxSetDigPatternStartTrigPattern(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternStartTrigPattern) DAQmxResetDigPatternStartTrigPattern;
int32 __CFUNC DAQmxResetDigPatternStartTrigPattern(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_FuncGen_Freq
 ***/
%rename(GetAOFuncGenFreq) DAQmxGetAOFuncGenFreq;
int32 __CFUNC DAQmxGetAOFuncGenFreq(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOFuncGenFreq) DAQmxSetAOFuncGenFreq;
int32 __CFUNC DAQmxSetAOFuncGenFreq(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOFuncGenFreq) DAQmxResetAOFuncGenFreq;
int32 __CFUNC DAQmxResetAOFuncGenFreq(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_RdyForStartEvent_OutputTerm
 ***/
%rename(GetExportedRdyForStartEventOutputTerm) DAQmxGetExportedRdyForStartEventOutputTerm;
int32 __CFUNC DAQmxGetExportedRdyForStartEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedRdyForStartEventOutputTerm) DAQmxSetExportedRdyForStartEventOutputTerm;
int32 __CFUNC DAQmxSetExportedRdyForStartEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedRdyForStartEventOutputTerm) DAQmxResetExportedRdyForStartEventOutputTerm;
int32 __CFUNC DAQmxResetExportedRdyForStartEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_SpaceAvail
 ***/
%rename(GetWriteSpaceAvail) DAQmxGetWriteSpaceAvail;
int32 __CFUNC DAQmxGetWriteSpaceAvail(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_SelfCal_LastTemp
 ***/
%rename(GetSelfCalLastTemp) DAQmxGetSelfCalLastTemp;
int32 __CFUNC DAQmxGetSelfCalLastTemp(const char deviceName[], float64 *data);
/*** Set/Get functions for DAQmx_Exported_HshkEvent_OutputBehavior
 *** Uses value set ExportActions5
 ***/
%rename(GetExportedHshkEventOutputBehavior) DAQmxGetExportedHshkEventOutputBehavior;
int32 __CFUNC DAQmxGetExportedHshkEventOutputBehavior(TaskHandle taskHandle, int32 *data);
%rename(SetExportedHshkEventOutputBehavior) DAQmxSetExportedHshkEventOutputBehavior;
int32 __CFUNC DAQmxSetExportedHshkEventOutputBehavior(TaskHandle taskHandle, int32 data);
%rename(ResetExportedHshkEventOutputBehavior) DAQmxResetExportedHshkEventOutputBehavior;
int32 __CFUNC DAQmxResetExportedHshkEventOutputBehavior(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_LineStates_PausedState Uses value
 *** set DigitalLineState
 ***/
%rename(GetDOLineStatesPausedState) DAQmxGetDOLineStatesPausedState;
int32 __CFUNC DAQmxGetDOLineStatesPausedState(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOLineStatesPausedState) DAQmxSetDOLineStatesPausedState;
int32 __CFUNC DAQmxSetDOLineStatesPausedState(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOLineStatesPausedState) DAQmxResetDOLineStatesPausedState;
int32 __CFUNC DAQmxResetDOLineStatesPausedState(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_SwitchChanList
 ***/
%rename(GetSwitchDevSwitchChanList) DAQmxGetSwitchDevSwitchChanList;
int32 __CFUNC DAQmxGetSwitchDevSwitchChanList(const char deviceName[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AO_DAC_Ref_Src Uses value set
 *** SourceSelection
 ***/
%rename(GetAODACRefSrc) DAQmxGetAODACRefSrc;
int32 __CFUNC DAQmxGetAODACRefSrc(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAODACRefSrc) DAQmxSetAODACRefSrc;
int32 __CFUNC DAQmxSetAODACRefSrc(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAODACRefSrc) DAQmxResetAODACRefSrc;
int32 __CFUNC DAQmxResetAODACRefSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_DO_SampClkSupported
 ***/
%rename(GetPhysicalChanDOSampClkSupported) DAQmxGetPhysicalChanDOSampClkSupported;
int32 __CFUNC DAQmxGetPhysicalChanDOSampClkSupported(const char physicalChannel[], bool32 *data);
/*** Set/Get functions for DAQmx_Dev_AI_SimultaneousSamplingSupported
 ***/
%rename(GetDevAISimultaneousSamplingSupported) DAQmxGetDevAISimultaneousSamplingSupported;
int32 __CFUNC DAQmxGetDevAISimultaneousSamplingSupported(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_MfgID
 ***/
%rename(GetPhysicalChanTEDSMfgID) DAQmxGetPhysicalChanTEDSMfgID;
int32 __CFUNC DAQmxGetPhysicalChanTEDSMfgID(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_Dev_CI_MaxSize
 ***/
%rename(GetDevCIMaxSize) DAQmxGetDevCIMaxSize;
int32 __CFUNC DAQmxGetDevCIMaxSize(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_SampQuant_SampPerChan
 ***/
%rename(GetSampQuantSampPerChan) DAQmxGetSampQuantSampPerChan;
int32 __CFUNC DAQmxGetSampQuantSampPerChan(TaskHandle taskHandle, uInt64 *data);
%rename(SetSampQuantSampPerChan) DAQmxSetSampQuantSampPerChan;
int32 __CFUNC DAQmxSetSampQuantSampPerChan(TaskHandle taskHandle, uInt64 data);
%rename(ResetSampQuantSampPerChan) DAQmxResetSampQuantSampPerChan;
int32 __CFUNC DAQmxResetSampQuantSampPerChan(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigEdge_StartTrig_DigFltr_TimebaseSrc
 ***/
%rename(GetDigEdgeStartTrigDigFltrTimebaseSrc) DAQmxGetDigEdgeStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeStartTrigDigFltrTimebaseSrc) DAQmxSetDigEdgeStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetDigEdgeStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeStartTrigDigFltrTimebaseSrc) DAQmxResetDigEdgeStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetDigEdgeStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_LVDT_SensitivityUnits Uses value
 *** set LVDTSensitivityUnits1
 ***/
%rename(GetAILVDTSensitivityUnits) DAQmxGetAILVDTSensitivityUnits;
int32 __CFUNC DAQmxGetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAILVDTSensitivityUnits) DAQmxSetAILVDTSensitivityUnits;
int32 __CFUNC DAQmxSetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAILVDTSensitivityUnits) DAQmxResetAILVDTSensitivityUnits;
int32 __CFUNC DAQmxResetAILVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_ReadAllAvailSamp
 ***/
%rename(GetReadReadAllAvailSamp) DAQmxGetReadReadAllAvailSamp;
int32 __CFUNC DAQmxGetReadReadAllAvailSamp(TaskHandle taskHandle, bool32 *data);
%rename(SetReadReadAllAvailSamp) DAQmxSetReadReadAllAvailSamp;
int32 __CFUNC DAQmxSetReadReadAllAvailSamp(TaskHandle taskHandle, bool32 data);
%rename(ResetReadReadAllAvailSamp) DAQmxResetReadReadAllAvailSamp;
int32 __CFUNC DAQmxResetReadReadAllAvailSamp(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_StartTrig_Delay
 ***/
%rename(GetStartTrigDelay) DAQmxGetStartTrigDelay;
int32 __CFUNC DAQmxGetStartTrigDelay(TaskHandle taskHandle, float64 *data);
%rename(SetStartTrigDelay) DAQmxSetStartTrigDelay;
int32 __CFUNC DAQmxSetStartTrigDelay(TaskHandle taskHandle, float64 data);
%rename(ResetStartTrigDelay) DAQmxResetStartTrigDelay;
int32 __CFUNC DAQmxResetStartTrigDelay(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigEdge_ArmStartTrig_DigFltr_Enable
 ***/
%rename(GetDigEdgeArmStartTrigDigFltrEnable) DAQmxGetDigEdgeArmStartTrigDigFltrEnable;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigEdgeArmStartTrigDigFltrEnable) DAQmxSetDigEdgeArmStartTrigDigFltrEnable;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigEdgeArmStartTrigDigFltrEnable) DAQmxResetDigEdgeArmStartTrigDigFltrEnable;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigDigFltrEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_CurrentShunt_Resistance
 ***/
%rename(GetAICurrentShuntResistance) DAQmxGetAICurrentShuntResistance;
int32 __CFUNC DAQmxGetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAICurrentShuntResistance) DAQmxSetAICurrentShuntResistance;
int32 __CFUNC DAQmxSetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAICurrentShuntResistance) DAQmxResetAICurrentShuntResistance;
int32 __CFUNC DAQmxResetAICurrentShuntResistance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchChan_MaxDCSwitchCurrent
 ***/
%rename(GetSwitchChanMaxDCSwitchCurrent) DAQmxGetSwitchChanMaxDCSwitchCurrent;
int32 __CFUNC DAQmxGetSwitchChanMaxDCSwitchCurrent(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_CI_Encoder_ZIndexEnable
 ***/
%rename(GetCIEncoderZIndexEnable) DAQmxGetCIEncoderZIndexEnable;
int32 __CFUNC DAQmxGetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderZIndexEnable) DAQmxSetCIEncoderZIndexEnable;
int32 __CFUNC DAQmxSetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderZIndexEnable) DAQmxResetCIEncoderZIndexEnable;
int32 __CFUNC DAQmxResetCIEncoderZIndexEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DI_DigFltr_MinPulseWidth
 ***/
%rename(GetDIDigFltrMinPulseWidth) DAQmxGetDIDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetDIDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetDIDigFltrMinPulseWidth) DAQmxSetDIDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetDIDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetDIDigFltrMinPulseWidth) DAQmxResetDIDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetDIDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_PreScaledUnits Uses value set
 *** UnitsPreScaled
 ***/
%rename(GetScalePreScaledUnits) DAQmxGetScalePreScaledUnits;
int32 __CFUNC DAQmxGetScalePreScaledUnits(const char scaleName[], int32 *data);
%rename(SetScalePreScaledUnits) DAQmxSetScalePreScaledUnits;
int32 __CFUNC DAQmxSetScalePreScaledUnits(const char scaleName[], int32 data);
/*** Set/Get functions for DAQmx_AO_EnhancedImageRejectionEnable
 ***/
%rename(GetAOEnhancedImageRejectionEnable) DAQmxGetAOEnhancedImageRejectionEnable;
int32 __CFUNC DAQmxGetAOEnhancedImageRejectionEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAOEnhancedImageRejectionEnable) DAQmxSetAOEnhancedImageRejectionEnable;
int32 __CFUNC DAQmxSetAOEnhancedImageRejectionEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAOEnhancedImageRejectionEnable) DAQmxResetAOEnhancedImageRejectionEnable;
int32 __CFUNC DAQmxResetAOEnhancedImageRejectionEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Accel_Sensitivity
 ***/
%rename(GetAIAccelSensitivity) DAQmxGetAIAccelSensitivity;
int32 __CFUNC DAQmxGetAIAccelSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIAccelSensitivity) DAQmxSetAIAccelSensitivity;
int32 __CFUNC DAQmxSetAIAccelSensitivity(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIAccelSensitivity) DAQmxResetAIAccelSensitivity;
int32 __CFUNC DAQmxResetAIAccelSensitivity(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_CtrTimebase_DigFltr_TimebaseSrc
 ***/
%rename(GetCOCtrTimebaseDigFltrTimebaseSrc) DAQmxGetCOCtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCOCtrTimebaseDigFltrTimebaseSrc) DAQmxSetCOCtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCOCtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCOCtrTimebaseDigFltrTimebaseSrc) DAQmxResetCOCtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Freq_MeasTime
 ***/
%rename(GetCIFreqMeasTime) DAQmxGetCIFreqMeasTime;
int32 __CFUNC DAQmxGetCIFreqMeasTime(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIFreqMeasTime) DAQmxSetCIFreqMeasTime;
int32 __CFUNC DAQmxSetCIFreqMeasTime(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIFreqMeasTime) DAQmxResetCIFreqMeasTime;
int32 __CFUNC DAQmxResetCIFreqMeasTime(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_ChanType Uses value set ChannelType
 ***/
%rename(GetChanType) DAQmxGetChanType;
int32 __CFUNC DAQmxGetChanType(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_Hshk_DelayAfterXfer
 ***/
%rename(GetHshkDelayAfterXfer) DAQmxGetHshkDelayAfterXfer;
int32 __CFUNC DAQmxGetHshkDelayAfterXfer(TaskHandle taskHandle, float64 *data);
%rename(SetHshkDelayAfterXfer) DAQmxSetHshkDelayAfterXfer;
int32 __CFUNC DAQmxSetHshkDelayAfterXfer(TaskHandle taskHandle, float64 data);
%rename(ResetHshkDelayAfterXfer) DAQmxResetHshkDelayAfterXfer;
int32 __CFUNC DAQmxResetHshkDelayAfterXfer(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_RdyForXferEvent_DeassertCond
 *** Uses value set DeassertCondition
 ***/
%rename(GetExportedRdyForXferEventDeassertCond) DAQmxGetExportedRdyForXferEventDeassertCond;
int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCond(TaskHandle taskHandle, int32 *data);
%rename(SetExportedRdyForXferEventDeassertCond) DAQmxSetExportedRdyForXferEventDeassertCond;
int32 __CFUNC DAQmxSetExportedRdyForXferEventDeassertCond(TaskHandle taskHandle, int32 data);
%rename(ResetExportedRdyForXferEventDeassertCond) DAQmxResetExportedRdyForXferEventDeassertCond;
int32 __CFUNC DAQmxResetExportedRdyForXferEventDeassertCond(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_AdvTrig_Pulse_Polarity Uses
 *** value set Polarity2
 ***/
%rename(GetExportedAdvTrigPulsePolarity) DAQmxGetExportedAdvTrigPulsePolarity;
int32 __CFUNC DAQmxGetExportedAdvTrigPulsePolarity(TaskHandle taskHandle, int32 *data);
/*** Set/Get functions for DAQmx_SampClk_TimingResponseMode Uses value
 *** set TimingResponseMode Obsolete - always returns 0
 ***/
%rename(GetSampClkTimingResponseMode) DAQmxGetSampClkTimingResponseMode;
int32 __CFUNC DAQmxGetSampClkTimingResponseMode(TaskHandle taskHandle, int32 *data);
%rename(SetSampClkTimingResponseMode) DAQmxSetSampClkTimingResponseMode;
int32 __CFUNC DAQmxSetSampClkTimingResponseMode(TaskHandle taskHandle, int32 data);
%rename(ResetSampClkTimingResponseMode) DAQmxResetSampClkTimingResponseMode;
int32 __CFUNC DAQmxResetSampClkTimingResponseMode(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_Dev_AO_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevAOTrigUsage) DAQmxGetDevAOTrigUsage;
int32 __CFUNC DAQmxGetDevAOTrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_DigFltr_Enable
 ***/
%rename(GetCISemiPeriodDigFltrEnable) DAQmxGetCISemiPeriodDigFltrEnable;
int32 __CFUNC DAQmxGetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCISemiPeriodDigFltrEnable) DAQmxSetCISemiPeriodDigFltrEnable;
int32 __CFUNC DAQmxSetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCISemiPeriodDigFltrEnable) DAQmxResetCISemiPeriodDigFltrEnable;
int32 __CFUNC DAQmxResetCISemiPeriodDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_OutputType Uses value set
 *** COOutputType
 ***/
%rename(GetCOOutputType) DAQmxGetCOOutputType;
int32 __CFUNC DAQmxGetCOOutputType(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_AI_Thrmcpl_CJCSrc Uses value set
 *** CJCSource1
 ***/
%rename(GetAIThrmcplCJCSrc) DAQmxGetAIThrmcplCJCSrc;
int32 __CFUNC DAQmxGetAIThrmcplCJCSrc(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_CI_CtrTimebase_DigFltr_MinPulseWidth
 ***/
%rename(GetCICtrTimebaseDigFltrMinPulseWidth) DAQmxGetCICtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICtrTimebaseDigFltrMinPulseWidth) DAQmxSetCICtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCICtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICtrTimebaseDigFltrMinPulseWidth) DAQmxResetCICtrTimebaseDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_AInput_DigSync_Enable
 ***/
%rename(GetCIEncoderAInputDigSyncEnable) DAQmxGetCIEncoderAInputDigSyncEnable;
int32 __CFUNC DAQmxGetCIEncoderAInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderAInputDigSyncEnable) DAQmxSetCIEncoderAInputDigSyncEnable;
int32 __CFUNC DAQmxSetCIEncoderAInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderAInputDigSyncEnable) DAQmxResetCIEncoderAInputDigSyncEnable;
int32 __CFUNC DAQmxResetCIEncoderAInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgEdge_RefTrig_Slope Uses value set
 *** Slope1
 ***/
%rename(GetAnlgEdgeRefTrigSlope) DAQmxGetAnlgEdgeRefTrigSlope;
int32 __CFUNC DAQmxGetAnlgEdgeRefTrigSlope(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgEdgeRefTrigSlope) DAQmxSetAnlgEdgeRefTrigSlope;
int32 __CFUNC DAQmxSetAnlgEdgeRefTrigSlope(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgEdgeRefTrigSlope) DAQmxResetAnlgEdgeRefTrigSlope;
int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSlope(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_Voltage_CurrentLimit
 ***/
%rename(GetAOVoltageCurrentLimit) DAQmxGetAOVoltageCurrentLimit;
int32 __CFUNC DAQmxGetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOVoltageCurrentLimit) DAQmxSetAOVoltageCurrentLimit;
int32 __CFUNC DAQmxSetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOVoltageCurrentLimit) DAQmxResetAOVoltageCurrentLimit;
int32 __CFUNC DAQmxResetAOVoltageCurrentLimit(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_PauseTrig_Top
 ***/
%rename(GetAnlgWinPauseTrigTop) DAQmxGetAnlgWinPauseTrigTop;
int32 __CFUNC DAQmxGetAnlgWinPauseTrigTop(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinPauseTrigTop) DAQmxSetAnlgWinPauseTrigTop;
int32 __CFUNC DAQmxSetAnlgWinPauseTrigTop(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinPauseTrigTop) DAQmxResetAnlgWinPauseTrigTop;
int32 __CFUNC DAQmxResetAnlgWinPauseTrigTop(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_VoltageIntExcitRangeVals
 ***/
%rename(GetDevAIVoltageIntExcitRangeVals) DAQmxGetDevAIVoltageIntExcitRangeVals;
int32 __CFUNC DAQmxGetDevAIVoltageIntExcitRangeVals(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_CustomScaleName
 ***/
%rename(GetAICustomScaleName) DAQmxGetAICustomScaleName;
int32 __CFUNC DAQmxGetAICustomScaleName(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAICustomScaleName) DAQmxSetAICustomScaleName;
int32 __CFUNC DAQmxSetAICustomScaleName(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAICustomScaleName) DAQmxResetAICustomScaleName;
int32 __CFUNC DAQmxResetAICustomScaleName(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CI_MaxTimebase
 ***/
%rename(GetDevCIMaxTimebase) DAQmxGetDevCIMaxTimebase;
int32 __CFUNC DAQmxGetDevCIMaxTimebase(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_AI_RTD_Type Uses value set RTDType1
 ***/
%rename(GetAIRTDType) DAQmxGetAIRTDType;
int32 __CFUNC DAQmxGetAIRTDType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIRTDType) DAQmxSetAIRTDType;
int32 __CFUNC DAQmxSetAIRTDType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIRTDType) DAQmxResetAIRTDType;
int32 __CFUNC DAQmxResetAIRTDType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Period_DigSync_Enable
 ***/
%rename(GetCIPeriodDigSyncEnable) DAQmxGetCIPeriodDigSyncEnable;
int32 __CFUNC DAQmxGetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIPeriodDigSyncEnable) DAQmxSetCIPeriodDigSyncEnable;
int32 __CFUNC DAQmxSetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIPeriodDigSyncEnable) DAQmxResetCIPeriodDigSyncEnable;
int32 __CFUNC DAQmxResetCIPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_Time_InitialDelay
 ***/
%rename(GetCOPulseTimeInitialDelay) DAQmxGetCOPulseTimeInitialDelay;
int32 __CFUNC DAQmxGetCOPulseTimeInitialDelay(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseTimeInitialDelay) DAQmxSetCOPulseTimeInitialDelay;
int32 __CFUNC DAQmxSetCOPulseTimeInitialDelay(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseTimeInitialDelay) DAQmxResetCOPulseTimeInitialDelay;
int32 __CFUNC DAQmxResetCOPulseTimeInitialDelay(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_UseOnlyOnBrdMem
 ***/
%rename(GetDOUseOnlyOnBrdMem) DAQmxGetDOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxGetDOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDOUseOnlyOnBrdMem) DAQmxSetDOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxSetDOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDOUseOnlyOnBrdMem) DAQmxResetDOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxResetDOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_Rate
 ***/
%rename(GetSampClkRate) DAQmxGetSampClkRate;
int32 __CFUNC DAQmxGetSampClkRate(TaskHandle taskHandle, float64 *data);
%rename(SetSampClkRate) DAQmxSetSampClkRate;
int32 __CFUNC DAQmxSetSampClkRate(TaskHandle taskHandle, float64 data);
%rename(ResetSampClkRate) DAQmxResetSampClkRate;
int32 __CFUNC DAQmxResetSampClkRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Current_ACRMS_Units Uses value set
 *** CurrentUnits1
 ***/
%rename(GetAICurrentACRMSUnits) DAQmxGetAICurrentACRMSUnits;
int32 __CFUNC DAQmxGetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAICurrentACRMSUnits) DAQmxSetAICurrentACRMSUnits;
int32 __CFUNC DAQmxSetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAICurrentACRMSUnits) DAQmxResetAICurrentACRMSUnits;
int32 __CFUNC DAQmxResetAICurrentACRMSUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_PulseWidth_DigFltr_MinPulseWidth
 ***/
%rename(GetCIPulseWidthDigFltrMinPulseWidth) DAQmxGetCIPulseWidthDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIPulseWidthDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIPulseWidthDigFltrMinPulseWidth) DAQmxSetCIPulseWidthDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIPulseWidthDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIPulseWidthDigFltrMinPulseWidth) DAQmxResetCIPulseWidthDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIPulseWidthDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Microphone_Sensitivity
 ***/
%rename(GetAIMicrophoneSensitivity) DAQmxGetAIMicrophoneSensitivity;
int32 __CFUNC DAQmxGetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIMicrophoneSensitivity) DAQmxSetAIMicrophoneSensitivity;
int32 __CFUNC DAQmxSetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIMicrophoneSensitivity) DAQmxResetAIMicrophoneSensitivity;
int32 __CFUNC DAQmxResetAIMicrophoneSensitivity(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_DigEdge_StartTrig_DigFltr_MinPulseWidth
 ***/
%rename(GetDigEdgeStartTrigDigFltrMinPulseWidth) DAQmxGetDigEdgeStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetDigEdgeStartTrigDigFltrMinPulseWidth) DAQmxSetDigEdgeStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetDigEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetDigEdgeStartTrigDigFltrMinPulseWidth) DAQmxResetDigEdgeStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetDigEdgeStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_AdvCmpltEvent_Pulse_Polarity
 *** Uses value set Polarity2
 ***/
%rename(GetExportedAdvCmpltEventPulsePolarity) DAQmxGetExportedAdvCmpltEventPulsePolarity;
int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedAdvCmpltEventPulsePolarity) DAQmxSetExportedAdvCmpltEventPulsePolarity;
int32 __CFUNC DAQmxSetExportedAdvCmpltEventPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedAdvCmpltEventPulsePolarity) DAQmxResetExportedAdvCmpltEventPulsePolarity;
int32 __CFUNC DAQmxResetExportedAdvCmpltEventPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Atten
 ***/
%rename(GetAIAtten) DAQmxGetAIAtten;
int32 __CFUNC DAQmxGetAIAtten(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIAtten) DAQmxSetAIAtten;
int32 __CFUNC DAQmxSetAIAtten(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIAtten) DAQmxResetAIAtten;
int32 __CFUNC DAQmxResetAIAtten(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_FuncGen_Amplitude
 ***/
%rename(GetAOFuncGenAmplitude) DAQmxGetAOFuncGenAmplitude;
int32 __CFUNC DAQmxGetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOFuncGenAmplitude) DAQmxSetAOFuncGenAmplitude;
int32 __CFUNC DAQmxSetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOFuncGenAmplitude) DAQmxResetAOFuncGenAmplitude;
int32 __CFUNC DAQmxResetAOFuncGenAmplitude(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_WatchdogExpirTrig_Edge Uses
 *** value set Edge1
 ***/
%rename(GetDigEdgeWatchdogExpirTrigEdge) DAQmxGetDigEdgeWatchdogExpirTrigEdge;
int32 __CFUNC DAQmxGetDigEdgeWatchdogExpirTrigEdge(TaskHandle taskHandle, int32 *data);
%rename(SetDigEdgeWatchdogExpirTrigEdge) DAQmxSetDigEdgeWatchdogExpirTrigEdge;
int32 __CFUNC DAQmxSetDigEdgeWatchdogExpirTrigEdge(TaskHandle taskHandle, int32 data);
%rename(ResetDigEdgeWatchdogExpirTrigEdge) DAQmxResetDigEdgeWatchdogExpirTrigEdge;
int32 __CFUNC DAQmxResetDigEdgeWatchdogExpirTrigEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_AdvTrig_OutputTerm
 ***/
%rename(GetExportedAdvTrigOutputTerm) DAQmxGetExportedAdvTrigOutputTerm;
int32 __CFUNC DAQmxGetExportedAdvTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedAdvTrigOutputTerm) DAQmxSetExportedAdvTrigOutputTerm;
int32 __CFUNC DAQmxSetExportedAdvTrigOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedAdvTrigOutputTerm) DAQmxResetExportedAdvTrigOutputTerm;
int32 __CFUNC DAQmxResetExportedAdvTrigOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Bridge_ShuntCal_Enable
 ***/
%rename(GetAIBridgeShuntCalEnable) DAQmxGetAIBridgeShuntCalEnable;
int32 __CFUNC DAQmxGetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIBridgeShuntCalEnable) DAQmxSetAIBridgeShuntCalEnable;
int32 __CFUNC DAQmxSetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIBridgeShuntCalEnable) DAQmxResetAIBridgeShuntCalEnable;
int32 __CFUNC DAQmxResetAIBridgeShuntCalEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Freq_DigFltr_MinPulseWidth
 ***/
%rename(GetCIFreqDigFltrMinPulseWidth) DAQmxGetCIFreqDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIFreqDigFltrMinPulseWidth) DAQmxSetCIFreqDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIFreqDigFltrMinPulseWidth) DAQmxResetCIFreqDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIFreqDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_DAC_Rng_High
 ***/
%rename(GetAODACRngHigh) DAQmxGetAODACRngHigh;
int32 __CFUNC DAQmxGetAODACRngHigh(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAODACRngHigh) DAQmxSetAODACRngHigh;
int32 __CFUNC DAQmxSetAODACRngHigh(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAODACRngHigh) DAQmxResetAODACRngHigh;
int32 __CFUNC DAQmxResetAODACRngHigh(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigPattern_StartTrig_When Uses value
 *** set DigitalPatternCondition1
 ***/
%rename(GetDigPatternStartTrigWhen) DAQmxGetDigPatternStartTrigWhen;
int32 __CFUNC DAQmxGetDigPatternStartTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetDigPatternStartTrigWhen) DAQmxSetDigPatternStartTrigWhen;
int32 __CFUNC DAQmxSetDigPatternStartTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetDigPatternStartTrigWhen) DAQmxResetDigPatternStartTrigWhen;
int32 __CFUNC DAQmxResetDigPatternStartTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_SampClkTimebase_OutputTerm
 ***/
%rename(GetExportedSampClkTimebaseOutputTerm) DAQmxGetExportedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxGetExportedSampClkTimebaseOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedSampClkTimebaseOutputTerm) DAQmxSetExportedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxSetExportedSampClkTimebaseOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedSampClkTimebaseOutputTerm) DAQmxResetExportedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxResetExportedSampClkTimebaseOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_PulseWidth_DigFltr_TimebaseSrc
 ***/
%rename(GetCIPulseWidthDigFltrTimebaseSrc) DAQmxGetCIPulseWidthDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIPulseWidthDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIPulseWidthDigFltrTimebaseSrc) DAQmxSetCIPulseWidthDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIPulseWidthDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIPulseWidthDigFltrTimebaseSrc) DAQmxResetCIPulseWidthDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Persisted Task Set/Get functions for DAQmx_PersistedTask_Author
 ***/
%rename(GetPersistedTaskAuthor) DAQmxGetPersistedTaskAuthor;
int32 __CFUNC DAQmxGetPersistedTaskAuthor(const char taskName[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Dev_Chassis_ModuleDevNames
 ***/
%rename(GetDevChassisModuleDevNames) DAQmxGetDevChassisModuleDevNames;
int32 __CFUNC DAQmxGetDevChassisModuleDevNames(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Exported_AdvCmpltEvent_Pulse_Width
 ***/
%rename(GetExportedAdvCmpltEventPulseWidth) DAQmxGetExportedAdvCmpltEventPulseWidth;
int32 __CFUNC DAQmxGetExportedAdvCmpltEventPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetExportedAdvCmpltEventPulseWidth) DAQmxSetExportedAdvCmpltEventPulseWidth;
int32 __CFUNC DAQmxSetExportedAdvCmpltEventPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetExportedAdvCmpltEventPulseWidth) DAQmxResetExportedAdvCmpltEventPulseWidth;
int32 __CFUNC DAQmxResetExportedAdvCmpltEventPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Is_TEDS
 ***/
%rename(GetAIIsTEDS) DAQmxGetAIIsTEDS;
int32 __CFUNC DAQmxGetAIIsTEDS(TaskHandle taskHandle, const char channel[], bool32 *data);
/*** Set/Get functions for DAQmx_DI_MemMapEnable
 ***/
%rename(GetDIMemMapEnable) DAQmxGetDIMemMapEnable;
int32 __CFUNC DAQmxGetDIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDIMemMapEnable) DAQmxSetDIMemMapEnable;
int32 __CFUNC DAQmxSetDIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDIMemMapEnable) DAQmxResetDIMemMapEnable;
int32 __CFUNC DAQmxResetDIMemMapEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_TermCfg Uses value set
 *** InputTermCfg
 ***/
%rename(GetAITermCfg) DAQmxGetAITermCfg;
int32 __CFUNC DAQmxGetAITermCfg(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAITermCfg) DAQmxSetAITermCfg;
int32 __CFUNC DAQmxSetAITermCfg(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAITermCfg) DAQmxResetAITermCfg;
int32 __CFUNC DAQmxResetAITermCfg(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ChanCal_Poly_ReverseCoeff
 ***/
%rename(GetAIChanCalPolyReverseCoeff) DAQmxGetAIChanCalPolyReverseCoeff;
int32 __CFUNC DAQmxGetAIChanCalPolyReverseCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalPolyReverseCoeff) DAQmxSetAIChanCalPolyReverseCoeff;
int32 __CFUNC DAQmxSetAIChanCalPolyReverseCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalPolyReverseCoeff) DAQmxResetAIChanCalPolyReverseCoeff;
int32 __CFUNC DAQmxResetAIChanCalPolyReverseCoeff(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_OutputState Uses value set Level1
 ***/
%rename(GetCOOutputState) DAQmxGetCOOutputState;
int32 __CFUNC DAQmxGetCOOutputState(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_DigEdge_AdvTrig_DigFltr_Enable
 ***/
%rename(GetDigEdgeAdvTrigDigFltrEnable) DAQmxGetDigEdgeAdvTrigDigFltrEnable;
int32 __CFUNC DAQmxGetDigEdgeAdvTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigEdgeAdvTrigDigFltrEnable) DAQmxSetDigEdgeAdvTrigDigFltrEnable;
int32 __CFUNC DAQmxSetDigEdgeAdvTrigDigFltrEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigEdgeAdvTrigDigFltrEnable) DAQmxResetDigEdgeAdvTrigDigFltrEnable;
int32 __CFUNC DAQmxResetDigEdgeAdvTrigDigFltrEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_CurrReadPos
 ***/
%rename(GetReadCurrReadPos) DAQmxGetReadCurrReadPos;
int32 __CFUNC DAQmxGetReadCurrReadPos(TaskHandle taskHandle, uInt64 *data);
/*** Set/Get functions for DAQmx_Exported_AdvTrig_Pulse_Width
 ***/
%rename(GetExportedAdvTrigPulseWidth) DAQmxGetExportedAdvTrigPulseWidth;
int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetExportedAdvTrigPulseWidth) DAQmxSetExportedAdvTrigPulseWidth;
int32 __CFUNC DAQmxSetExportedAdvTrigPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetExportedAdvTrigPulseWidth) DAQmxResetExportedAdvTrigPulseWidth;
int32 __CFUNC DAQmxResetExportedAdvTrigPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_RefTrig_PretrigSamples
 ***/
%rename(GetRefTrigPretrigSamples) DAQmxGetRefTrigPretrigSamples;
int32 __CFUNC DAQmxGetRefTrigPretrigSamples(TaskHandle taskHandle, uInt32 *data);
%rename(SetRefTrigPretrigSamples) DAQmxSetRefTrigPretrigSamples;
int32 __CFUNC DAQmxSetRefTrigPretrigSamples(TaskHandle taskHandle, uInt32 data);
%rename(ResetRefTrigPretrigSamples) DAQmxResetRefTrigPretrigSamples;
int32 __CFUNC DAQmxResetRefTrigPretrigSamples(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_PersistedChan_AllowInteractiveDeletion
 ***/
%rename(GetPersistedChanAllowInteractiveDeletion) DAQmxGetPersistedChanAllowInteractiveDeletion;
int32 __CFUNC DAQmxGetPersistedChanAllowInteractiveDeletion(const char channel[], bool32 *data);

/*** Set/Get functions for DAQmx_AI_EddyCurrentProxProbe_Sensitivity
 ***/
%rename(GetAIEddyCurrentProxProbeSensitivity) DAQmxGetAIEddyCurrentProxProbeSensitivity;
int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIEddyCurrentProxProbeSensitivity) DAQmxSetAIEddyCurrentProxProbeSensitivity;
int32 __CFUNC DAQmxSetAIEddyCurrentProxProbeSensitivity(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIEddyCurrentProxProbeSensitivity) DAQmxResetAIEddyCurrentProxProbeSensitivity;
int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivity(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_RefClk_Src
 ***/
%rename(GetRefClkSrc) DAQmxGetRefClkSrc;
int32 __CFUNC DAQmxGetRefClkSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetRefClkSrc) DAQmxSetRefClkSrc;
int32 __CFUNC DAQmxSetRefClkSrc(TaskHandle taskHandle, const char *data);
%rename(ResetRefClkSrc) DAQmxResetRefClkSrc;
int32 __CFUNC DAQmxResetRefClkSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Scale_Map_ScaledMax
 ***/
%rename(GetScaleMapScaledMax) DAQmxGetScaleMapScaledMax;
int32 __CFUNC DAQmxGetScaleMapScaledMax(const char scaleName[], float64 *data);
%rename(SetScaleMapScaledMax) DAQmxSetScaleMapScaledMax;
int32 __CFUNC DAQmxSetScaleMapScaledMax(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_TemplateIDs
 ***/
%rename(GetPhysicalChanTEDSTemplateIDs) DAQmxGetPhysicalChanTEDSTemplateIDs;
int32 __CFUNC DAQmxGetPhysicalChanTEDSTemplateIDs(const char physicalChannel[], uInt32 *data, uInt32 arraySizeInSamples);

/*** Set/Get functions for DAQmx_AI_RTD_C
 ***/
%rename(GetAIRTDC) DAQmxGetAIRTDC;
int32 __CFUNC DAQmxGetAIRTDC(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRTDC) DAQmxSetAIRTDC;
int32 __CFUNC DAQmxSetAIRTDC(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRTDC) DAQmxResetAIRTDC;
int32 __CFUNC DAQmxResetAIRTDC(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_DI_SampClkSupported
 ***/
%rename(GetPhysicalChanDISampClkSupported) DAQmxGetPhysicalChanDISampClkSupported;
int32 __CFUNC DAQmxGetPhysicalChanDISampClkSupported(const char physicalChannel[], bool32 *data);
/*** Set/Get functions for DAQmx_Read_ChannelsToRead
 ***/
%rename(GetReadChannelsToRead) DAQmxGetReadChannelsToRead;
int32 __CFUNC DAQmxGetReadChannelsToRead(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetReadChannelsToRead) DAQmxSetReadChannelsToRead;
int32 __CFUNC DAQmxSetReadChannelsToRead(TaskHandle taskHandle, const char *data);
%rename(ResetReadChannelsToRead) DAQmxResetReadChannelsToRead;
int32 __CFUNC DAQmxResetReadChannelsToRead(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgWin_StartTrig_When Uses value set
 *** WindowTriggerCondition1
 ***/
%rename(GetAnlgWinStartTrigWhen) DAQmxGetAnlgWinStartTrigWhen;
int32 __CFUNC DAQmxGetAnlgWinStartTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinStartTrigWhen) DAQmxSetAnlgWinStartTrigWhen;
int32 __CFUNC DAQmxSetAnlgWinStartTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinStartTrigWhen) DAQmxResetAnlgWinStartTrigWhen;
int32 __CFUNC DAQmxResetAnlgWinStartTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_RealTime_NumOfWarmupIters
 ***/
%rename(GetRealTimeNumOfWarmupIters) DAQmxGetRealTimeNumOfWarmupIters;
int32 __CFUNC DAQmxGetRealTimeNumOfWarmupIters(TaskHandle taskHandle, uInt32 *data);
%rename(SetRealTimeNumOfWarmupIters) DAQmxSetRealTimeNumOfWarmupIters;
int32 __CFUNC DAQmxSetRealTimeNumOfWarmupIters(TaskHandle taskHandle, uInt32 data);
%rename(ResetRealTimeNumOfWarmupIters) DAQmxResetRealTimeNumOfWarmupIters;
int32 __CFUNC DAQmxResetRealTimeNumOfWarmupIters(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_RefTrig_Type Uses value set
 *** TriggerType8
 ***/
%rename(GetRefTrigType) DAQmxGetRefTrigType;
int32 __CFUNC DAQmxGetRefTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetRefTrigType) DAQmxSetRefTrigType;
int32 __CFUNC DAQmxSetRefTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetRefTrigType) DAQmxResetRefTrigType;
int32 __CFUNC DAQmxResetRefTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_DAC_Offset_ExtSrc
 ***/
%rename(GetAODACOffsetExtSrc) DAQmxGetAODACOffsetExtSrc;
int32 __CFUNC DAQmxGetAODACOffsetExtSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAODACOffsetExtSrc) DAQmxSetAODACOffsetExtSrc;
int32 __CFUNC DAQmxSetAODACOffsetExtSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAODACOffsetExtSrc) DAQmxResetAODACOffsetExtSrc;
int32 __CFUNC DAQmxResetAODACOffsetExtSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_ChanDescr
 ***/
%rename(GetChanDescr) DAQmxGetChanDescr;
int32 __CFUNC DAQmxGetChanDescr(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetChanDescr) DAQmxSetChanDescr;
int32 __CFUNC DAQmxSetChanDescr(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetChanDescr) DAQmxResetChanDescr;
int32 __CFUNC DAQmxResetChanDescr(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Write_RegenMode Uses value set
 *** RegenerationMode1
 ***/
%rename(GetWriteRegenMode) DAQmxGetWriteRegenMode;
int32 __CFUNC DAQmxGetWriteRegenMode(TaskHandle taskHandle, int32 *data);
%rename(SetWriteRegenMode) DAQmxSetWriteRegenMode;
int32 __CFUNC DAQmxSetWriteRegenMode(TaskHandle taskHandle, int32 data);
%rename(ResetWriteRegenMode) DAQmxResetWriteRegenMode;
int32 __CFUNC DAQmxResetWriteRegenMode(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_DigEdge_ArmStartTrig_DigFltr_TimebaseSrc
 ***/
%rename(GetDigEdgeArmStartTrigDigFltrTimebaseSrc) DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeArmStartTrigDigFltrTimebaseSrc) DAQmxSetDigEdgeArmStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeArmStartTrigDigFltrTimebaseSrc) DAQmxResetDigEdgeArmStartTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigDigFltrTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampClk_TimebaseDiv
 ***/
%rename(GetSampClkTimebaseDiv) DAQmxGetSampClkTimebaseDiv;
int32 __CFUNC DAQmxGetSampClkTimebaseDiv(TaskHandle taskHandle, uInt32 *data);
%rename(SetSampClkTimebaseDiv) DAQmxSetSampClkTimebaseDiv;
int32 __CFUNC DAQmxSetSampClkTimebaseDiv(TaskHandle taskHandle, uInt32 data);
%rename(ResetSampClkTimebaseDiv) DAQmxResetSampClkTimebaseDiv;
int32 __CFUNC DAQmxResetSampClkTimebaseDiv(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Task_Channels
 ***/
%rename(GetTaskChannels) DAQmxGetTaskChannels;
int32 __CFUNC DAQmxGetTaskChannels(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Exported_10MHzRefClk_OutputTerm
 ***/
%rename(GetExported10MHzRefClkOutputTerm) DAQmxGetExported10MHzRefClkOutputTerm;
int32 __CFUNC DAQmxGetExported10MHzRefClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExported10MHzRefClkOutputTerm) DAQmxSetExported10MHzRefClkOutputTerm;
int32 __CFUNC DAQmxSetExported10MHzRefClkOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExported10MHzRefClkOutputTerm) DAQmxResetExported10MHzRefClkOutputTerm;
int32 __CFUNC DAQmxResetExported10MHzRefClkOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_RawDataCompressionType Uses value
 *** set RawDataCompressionType
 ***/
%rename(GetAIRawDataCompressionType) DAQmxGetAIRawDataCompressionType;
int32 __CFUNC DAQmxGetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIRawDataCompressionType) DAQmxSetAIRawDataCompressionType;
int32 __CFUNC DAQmxSetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIRawDataCompressionType) DAQmxResetAIRawDataCompressionType;
int32 __CFUNC DAQmxResetAIRawDataCompressionType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_RefTrig_Edge Uses value set
 *** Edge1
 ***/
%rename(GetDigEdgeRefTrigEdge) DAQmxGetDigEdgeRefTrigEdge;
int32 __CFUNC DAQmxGetDigEdgeRefTrigEdge(TaskHandle taskHandle, int32 *data);
%rename(SetDigEdgeRefTrigEdge) DAQmxSetDigEdgeRefTrigEdge;
int32 __CFUNC DAQmxSetDigEdgeRefTrigEdge(TaskHandle taskHandle, int32 data);
%rename(ResetDigEdgeRefTrigEdge) DAQmxResetDigEdgeRefTrigEdge;
int32 __CFUNC DAQmxResetDigEdgeRefTrigEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_DO_MaxRate
 ***/
%rename(GetDevDOMaxRate) DAQmxGetDevDOMaxRate;
int32 __CFUNC DAQmxGetDevDOMaxRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_AO_Current_Units Uses value set
 *** CurrentUnits1
 ***/
%rename(GetAOCurrentUnits) DAQmxGetAOCurrentUnits;
int32 __CFUNC DAQmxGetAOCurrentUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOCurrentUnits) DAQmxSetAOCurrentUnits;
int32 __CFUNC DAQmxSetAOCurrentUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOCurrentUnits) DAQmxResetAOCurrentUnits;
int32 __CFUNC DAQmxResetAOCurrentUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_AngEncoder_PulsesPerRev
 ***/
%rename(GetCIAngEncoderPulsesPerRev) DAQmxGetCIAngEncoderPulsesPerRev;
int32 __CFUNC DAQmxGetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCIAngEncoderPulsesPerRev) DAQmxSetCIAngEncoderPulsesPerRev;
int32 __CFUNC DAQmxSetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCIAngEncoderPulsesPerRev) DAQmxResetCIAngEncoderPulsesPerRev;
int32 __CFUNC DAQmxResetCIAngEncoderPulsesPerRev(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_Time_Units Uses value set
 *** TimeUnits2
 ***/
%rename(GetCOPulseTimeUnits) DAQmxGetCOPulseTimeUnits;
int32 __CFUNC DAQmxGetCOPulseTimeUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCOPulseTimeUnits) DAQmxSetCOPulseTimeUnits;
int32 __CFUNC DAQmxSetCOPulseTimeUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCOPulseTimeUnits) DAQmxResetCOPulseTimeUnits;
int32 __CFUNC DAQmxResetCOPulseTimeUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_Timebase_ActiveEdge Uses
 *** value set Edge1
 ***/
%rename(GetSampClkTimebaseActiveEdge) DAQmxGetSampClkTimebaseActiveEdge;
int32 __CFUNC DAQmxGetSampClkTimebaseActiveEdge(TaskHandle taskHandle, int32 *data);
%rename(SetSampClkTimebaseActiveEdge) DAQmxSetSampClkTimebaseActiveEdge;
int32 __CFUNC DAQmxSetSampClkTimebaseActiveEdge(TaskHandle taskHandle, int32 data);
%rename(ResetSampClkTimebaseActiveEdge) DAQmxResetSampClkTimebaseActiveEdge;
int32 __CFUNC DAQmxResetSampClkTimebaseActiveEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_CtrOutEvent_Pulse_Polarity
 *** Uses value set Polarity2
 ***/
%rename(GetExportedCtrOutEventPulsePolarity) DAQmxGetExportedCtrOutEventPulsePolarity;
int32 __CFUNC DAQmxGetExportedCtrOutEventPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedCtrOutEventPulsePolarity) DAQmxSetExportedCtrOutEventPulsePolarity;
int32 __CFUNC DAQmxSetExportedCtrOutEventPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedCtrOutEventPulsePolarity) DAQmxResetExportedCtrOutEventPulsePolarity;
int32 __CFUNC DAQmxResetExportedCtrOutEventPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_MemMapEnable
 ***/
%rename(GetDOMemMapEnable) DAQmxGetDOMemMapEnable;
int32 __CFUNC DAQmxGetDOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDOMemMapEnable) DAQmxSetDOMemMapEnable;
int32 __CFUNC DAQmxSetDOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDOMemMapEnable) DAQmxResetDOMemMapEnable;
int32 __CFUNC DAQmxResetDOMemMapEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_DataXferCustomThreshold
 ***/
%rename(GetAIDataXferCustomThreshold) DAQmxGetAIDataXferCustomThreshold;
int32 __CFUNC DAQmxGetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAIDataXferCustomThreshold) DAQmxSetAIDataXferCustomThreshold;
int32 __CFUNC DAQmxSetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAIDataXferCustomThreshold) DAQmxResetAIDataXferCustomThreshold;
int32 __CFUNC DAQmxResetAIDataXferCustomThreshold(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_BInput_DigFltr_TimebaseRate
 ***/
%rename(GetCIEncoderBInputDigFltrTimebaseRate) DAQmxGetCIEncoderBInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderBInputDigFltrTimebaseRate) DAQmxSetCIEncoderBInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIEncoderBInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderBInputDigFltrTimebaseRate) DAQmxResetCIEncoderBInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_DataXferMech Uses value set
 *** DataTransferMechanism
 ***/
%rename(GetAIDataXferMech) DAQmxGetAIDataXferMech;
int32 __CFUNC DAQmxGetAIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIDataXferMech) DAQmxSetAIDataXferMech;
int32 __CFUNC DAQmxSetAIDataXferMech(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIDataXferMech) DAQmxResetAIDataXferMech;
int32 __CFUNC DAQmxResetAIDataXferMech(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Task_Devices
 ***/
%rename(GetTaskDevices) DAQmxGetTaskDevices;
int32 __CFUNC DAQmxGetTaskDevices(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AI_Rng_High
 ***/
%rename(GetAIRngHigh) DAQmxGetAIRngHigh;
int32 __CFUNC DAQmxGetAIRngHigh(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRngHigh) DAQmxSetAIRngHigh;
int32 __CFUNC DAQmxSetAIRngHigh(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRngHigh) DAQmxResetAIRngHigh;
int32 __CFUNC DAQmxResetAIRngHigh(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SyncPulse_SyncTime
 ***/
%rename(GetSyncPulseSyncTime) DAQmxGetSyncPulseSyncTime;
int32 __CFUNC DAQmxGetSyncPulseSyncTime(TaskHandle taskHandle, float64 *data);
/*** Set/Get functions for DAQmx_CI_Freq_DigFltr_Enable
 ***/
%rename(GetCIFreqDigFltrEnable) DAQmxGetCIFreqDigFltrEnable;
int32 __CFUNC DAQmxGetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIFreqDigFltrEnable) DAQmxSetCIFreqDigFltrEnable;
int32 __CFUNC DAQmxSetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIFreqDigFltrEnable) DAQmxResetCIFreqDigFltrEnable;
int32 __CFUNC DAQmxResetCIFreqDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_PXI_SlotNum
 ***/
%rename(GetDevPXISlotNum) DAQmxGetDevPXISlotNum;
int32 __CFUNC DAQmxGetDevPXISlotNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_DI_AcquireOn Uses value set
 *** SampleClockActiveOrInactiveEdgeSelection
 ***/
%rename(GetDIAcquireOn) DAQmxGetDIAcquireOn;
int32 __CFUNC DAQmxGetDIAcquireOn(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDIAcquireOn) DAQmxSetDIAcquireOn;
int32 __CFUNC DAQmxSetDIAcquireOn(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDIAcquireOn) DAQmxResetDIAcquireOn;
int32 __CFUNC DAQmxResetDIAcquireOn(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_PulseWidth_DigFltr_TimebaseRate
 ***/
%rename(GetCIPulseWidthDigFltrTimebaseRate) DAQmxGetCIPulseWidthDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIPulseWidthDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIPulseWidthDigFltrTimebaseRate) DAQmxSetCIPulseWidthDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIPulseWidthDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIPulseWidthDigFltrTimebaseRate) DAQmxResetCIPulseWidthDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIPulseWidthDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_PauseTrig_When Uses value set
 *** WindowTriggerCondition2
 ***/
%rename(GetAnlgWinPauseTrigWhen) DAQmxGetAnlgWinPauseTrigWhen;
int32 __CFUNC DAQmxGetAnlgWinPauseTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinPauseTrigWhen) DAQmxSetAnlgWinPauseTrigWhen;
int32 __CFUNC DAQmxSetAnlgWinPauseTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinPauseTrigWhen) DAQmxResetAnlgWinPauseTrigWhen;
int32 __CFUNC DAQmxResetAnlgWinPauseTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_FreqRngs
 ***/
%rename(GetDevAIFreqRngs) DAQmxGetDevAIFreqRngs;
int32 __CFUNC DAQmxGetDevAIFreqRngs(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_CI_Period_StartingEdge Uses value set
 *** Edge1
 ***/
%rename(GetCIPeriodStartingEdge) DAQmxGetCIPeriodStartingEdge;
int32 __CFUNC DAQmxGetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIPeriodStartingEdge) DAQmxSetCIPeriodStartingEdge;
int32 __CFUNC DAQmxSetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIPeriodStartingEdge) DAQmxResetCIPeriodStartingEdge;
int32 __CFUNC DAQmxResetCIPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_PauseTrig_OutputTerm
 ***/
%rename(GetExportedPauseTrigOutputTerm) DAQmxGetExportedPauseTrigOutputTerm;
int32 __CFUNC DAQmxGetExportedPauseTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedPauseTrigOutputTerm) DAQmxSetExportedPauseTrigOutputTerm;
int32 __CFUNC DAQmxSetExportedPauseTrigOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedPauseTrigOutputTerm) DAQmxResetExportedPauseTrigOutputTerm;
int32 __CFUNC DAQmxResetExportedPauseTrigOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DI_LogicFamily Uses value set
 *** LogicFamily
 ***/
%rename(GetDILogicFamily) DAQmxGetDILogicFamily;
int32 __CFUNC DAQmxGetDILogicFamily(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDILogicFamily) DAQmxSetDILogicFamily;
int32 __CFUNC DAQmxSetDILogicFamily(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDILogicFamily) DAQmxResetDILogicFamily;
int32 __CFUNC DAQmxResetDILogicFamily(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_SampClk_Pulse_Polarity Uses
 *** value set Polarity2
 ***/
%rename(GetExportedSampClkPulsePolarity) DAQmxGetExportedSampClkPulsePolarity;
int32 __CFUNC DAQmxGetExportedSampClkPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedSampClkPulsePolarity) DAQmxSetExportedSampClkPulsePolarity;
int32 __CFUNC DAQmxSetExportedSampClkPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedSampClkPulsePolarity) DAQmxResetExportedSampClkPulsePolarity;
int32 __CFUNC DAQmxResetExportedSampClkPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AIConv_ActiveEdge Uses value set
 *** Edge1
 ***/
%rename(GetAIConvActiveEdge) DAQmxGetAIConvActiveEdge;
int32 __CFUNC DAQmxGetAIConvActiveEdge(TaskHandle taskHandle, int32 *data);
%rename(SetAIConvActiveEdge) DAQmxSetAIConvActiveEdge;
int32 __CFUNC DAQmxSetAIConvActiveEdge(TaskHandle taskHandle, int32 data);
%rename(ResetAIConvActiveEdge) DAQmxResetAIConvActiveEdge;
int32 __CFUNC DAQmxResetAIConvActiveEdge(TaskHandle taskHandle);
%rename(GetAIConvActiveEdgeEx) DAQmxGetAIConvActiveEdgeEx;
int32 __CFUNC DAQmxGetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[], int32 *data);
%rename(SetAIConvActiveEdgeEx) DAQmxSetAIConvActiveEdgeEx;
int32 __CFUNC DAQmxSetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[], int32 data);
%rename(ResetAIConvActiveEdgeEx) DAQmxResetAIConvActiveEdgeEx;
int32 __CFUNC DAQmxResetAIConvActiveEdgeEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_AnlgEdge_StartTrig_Hyst
 ***/
%rename(GetAnlgEdgeStartTrigHyst) DAQmxGetAnlgEdgeStartTrigHyst;
int32 __CFUNC DAQmxGetAnlgEdgeStartTrigHyst(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgEdgeStartTrigHyst) DAQmxSetAnlgEdgeStartTrigHyst;
int32 __CFUNC DAQmxSetAnlgEdgeStartTrigHyst(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgEdgeStartTrigHyst) DAQmxResetAnlgEdgeStartTrigHyst;
int32 __CFUNC DAQmxResetAnlgEdgeStartTrigHyst(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_AutoZeroMode Uses value set
 *** AutoZeroType1
 ***/
%rename(GetAIAutoZeroMode) DAQmxGetAIAutoZeroMode;
int32 __CFUNC DAQmxGetAIAutoZeroMode(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIAutoZeroMode) DAQmxSetAIAutoZeroMode;
int32 __CFUNC DAQmxSetAIAutoZeroMode(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIAutoZeroMode) DAQmxResetAIAutoZeroMode;
int32 __CFUNC DAQmxResetAIAutoZeroMode(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Gain
 ***/
%rename(GetAIGain) DAQmxGetAIGain;
int32 __CFUNC DAQmxGetAIGain(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIGain) DAQmxSetAIGain;
int32 __CFUNC DAQmxSetAIGain(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIGain) DAQmxResetAIGain;
int32 __CFUNC DAQmxResetAIGain(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_ChangeDetect_HasOverflowed
 ***/
%rename(GetReadChangeDetectHasOverflowed) DAQmxGetReadChangeDetectHasOverflowed;
int32 __CFUNC DAQmxGetReadChangeDetectHasOverflowed(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_SampClk_Timebase_MasterTimebaseDiv
 ***/
%rename(GetSampClkTimebaseMasterTimebaseDiv) DAQmxGetSampClkTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxGetSampClkTimebaseMasterTimebaseDiv(TaskHandle taskHandle, uInt32 *data);
%rename(SetSampClkTimebaseMasterTimebaseDiv) DAQmxSetSampClkTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxSetSampClkTimebaseMasterTimebaseDiv(TaskHandle taskHandle, uInt32 data);
%rename(ResetSampClkTimebaseMasterTimebaseDiv) DAQmxResetSampClkTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxResetSampClkTimebaseMasterTimebaseDiv(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_PhysicalChan_AO_TermCfgs Uses bits
 *** from enum TerminalConfigurationBits
 ***/
%rename(GetPhysicalChanAOTermCfgs) DAQmxGetPhysicalChanAOTermCfgs;
int32 __CFUNC DAQmxGetPhysicalChanAOTermCfgs(const char physicalChannel[], int32 *data);
/*** Set/Get functions for DAQmx_AI_RVDT_Sensitivity
 ***/
%rename(GetAIRVDTSensitivity) DAQmxGetAIRVDTSensitivity;
int32 __CFUNC DAQmxGetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRVDTSensitivity) DAQmxSetAIRVDTSensitivity;
int32 __CFUNC DAQmxSetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRVDTSensitivity) DAQmxResetAIRVDTSensitivity;
int32 __CFUNC DAQmxResetAIRVDTSensitivity(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_ScaledUnits
 ***/
%rename(GetScaleScaledUnits) DAQmxGetScaleScaledUnits;
int32 __CFUNC DAQmxGetScaleScaledUnits(const char scaleName[], char *data, uInt32 bufferSize);
%rename(SetScaleScaledUnits) DAQmxSetScaleScaledUnits;
int32 __CFUNC DAQmxSetScaleScaledUnits(const char scaleName[], const char *data);
/*** Set/Get functions for DAQmx_Exported_AdvTrig_Pulse_WidthUnits
 *** Uses value set DigitalWidthUnits3
 ***/
%rename(GetExportedAdvTrigPulseWidthUnits) DAQmxGetExportedAdvTrigPulseWidthUnits;
int32 __CFUNC DAQmxGetExportedAdvTrigPulseWidthUnits(TaskHandle taskHandle, int32 *data);
%rename(SetExportedAdvTrigPulseWidthUnits) DAQmxSetExportedAdvTrigPulseWidthUnits;
int32 __CFUNC DAQmxSetExportedAdvTrigPulseWidthUnits(TaskHandle taskHandle, int32 data);
%rename(ResetExportedAdvTrigPulseWidthUnits) DAQmxResetExportedAdvTrigPulseWidthUnits;
int32 __CFUNC DAQmxResetExportedAdvTrigPulseWidthUnits(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_PhysicalChan_DO_PortWidth
 ***/
%rename(GetPhysicalChanDOPortWidth) DAQmxGetPhysicalChanDOPortWidth;
int32 __CFUNC DAQmxGetPhysicalChanDOPortWidth(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_AI_RVDT_SensitivityUnits Uses value
 *** set RVDTSensitivityUnits1
 ***/
%rename(GetAIRVDTSensitivityUnits) DAQmxGetAIRVDTSensitivityUnits;
int32 __CFUNC DAQmxGetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIRVDTSensitivityUnits) DAQmxSetAIRVDTSensitivityUnits;
int32 __CFUNC DAQmxSetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIRVDTSensitivityUnits) DAQmxResetAIRVDTSensitivityUnits;
int32 __CFUNC DAQmxResetAIRVDTSensitivityUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_StartTrig_OutputTerm
 ***/
%rename(GetExportedStartTrigOutputTerm) DAQmxGetExportedStartTrigOutputTerm;
int32 __CFUNC DAQmxGetExportedStartTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedStartTrigOutputTerm) DAQmxSetExportedStartTrigOutputTerm;
int32 __CFUNC DAQmxSetExportedStartTrigOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedStartTrigOutputTerm) DAQmxResetExportedStartTrigOutputTerm;
int32 __CFUNC DAQmxResetExportedStartTrigOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigEdge_ArmStartTrig_Src
 ***/
%rename(GetDigEdgeArmStartTrigSrc) DAQmxGetDigEdgeArmStartTrigSrc;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeArmStartTrigSrc) DAQmxSetDigEdgeArmStartTrigSrc;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeArmStartTrigSrc) DAQmxResetDigEdgeArmStartTrigSrc;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_AngEncoder_Units Uses value set
 *** AngleUnits2
 ***/
%rename(GetCIAngEncoderUnits) DAQmxGetCIAngEncoderUnits;
int32 __CFUNC DAQmxGetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIAngEncoderUnits) DAQmxSetCIAngEncoderUnits;
int32 __CFUNC DAQmxSetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIAngEncoderUnits) DAQmxResetCIAngEncoderUnits;
int32 __CFUNC DAQmxResetCIAngEncoderUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_CommonModeRangeErrorChans
 ***/
%rename(GetReadCommonModeRangeErrorChans) DAQmxGetReadCommonModeRangeErrorChans;
int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_ExtCal_LastTemp
 ***/
%rename(GetExtCalLastTemp) DAQmxGetExtCalLastTemp;
int32 __CFUNC DAQmxGetExtCalLastTemp(const char deviceName[], float64 *data);
/*** Set/Get functions for DAQmx_Exported_AdvCmpltEvent_Delay
 ***/
%rename(GetExportedAdvCmpltEventDelay) DAQmxGetExportedAdvCmpltEventDelay;
int32 __CFUNC DAQmxGetExportedAdvCmpltEventDelay(TaskHandle taskHandle, float64 *data);
%rename(SetExportedAdvCmpltEventDelay) DAQmxSetExportedAdvCmpltEventDelay;
int32 __CFUNC DAQmxSetExportedAdvCmpltEventDelay(TaskHandle taskHandle, float64 data);
%rename(ResetExportedAdvCmpltEventDelay) DAQmxResetExportedAdvCmpltEventDelay;
int32 __CFUNC DAQmxResetExportedAdvCmpltEventDelay(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_RefClk_Rate
 ***/
%rename(GetRefClkRate) DAQmxGetRefClkRate;
int32 __CFUNC DAQmxGetRefClkRate(TaskHandle taskHandle, float64 *data);
%rename(SetRefClkRate) DAQmxSetRefClkRate;
int32 __CFUNC DAQmxSetRefClkRate(TaskHandle taskHandle, float64 data);
%rename(ResetRefClkRate) DAQmxResetRefClkRate;
int32 __CFUNC DAQmxResetRefClkRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_LinEncoder_InitialPos
 ***/
%rename(GetCILinEncoderInitialPos) DAQmxGetCILinEncoderInitialPos;
int32 __CFUNC DAQmxGetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCILinEncoderInitialPos) DAQmxSetCILinEncoderInitialPos;
int32 __CFUNC DAQmxSetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCILinEncoderInitialPos) DAQmxResetCILinEncoderInitialPos;
int32 __CFUNC DAQmxResetCILinEncoderInitialPos(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_PulseWidth_StartingEdge Uses value
 *** set Edge1
 ***/
%rename(GetCIPulseWidthStartingEdge) DAQmxGetCIPulseWidthStartingEdge;
int32 __CFUNC DAQmxGetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIPulseWidthStartingEdge) DAQmxSetCIPulseWidthStartingEdge;
int32 __CFUNC DAQmxSetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIPulseWidthStartingEdge) DAQmxResetCIPulseWidthStartingEdge;
int32 __CFUNC DAQmxResetCIPulseWidthStartingEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_SampAndHold_Enable
 ***/
%rename(GetAISampAndHoldEnable) DAQmxGetAISampAndHoldEnable;
int32 __CFUNC DAQmxGetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAISampAndHoldEnable) DAQmxSetAISampAndHoldEnable;
int32 __CFUNC DAQmxSetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAISampAndHoldEnable) DAQmxResetAISampAndHoldEnable;
int32 __CFUNC DAQmxResetAISampAndHoldEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ChanCal_Table_ScaledVals
 ***/
%rename(GetAIChanCalTableScaledVals) DAQmxGetAIChanCalTableScaledVals;
int32 __CFUNC DAQmxGetAIChanCalTableScaledVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalTableScaledVals) DAQmxSetAIChanCalTableScaledVals;
int32 __CFUNC DAQmxSetAIChanCalTableScaledVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalTableScaledVals) DAQmxResetAIChanCalTableScaledVals;
int32 __CFUNC DAQmxResetAIChanCalTableScaledVals(TaskHandle taskHandle, const char channel[]);
/*** Watchdog Set/Get functions for DAQmx_Watchdog_Timeout
 ***/
%rename(GetWatchdogTimeout) DAQmxGetWatchdogTimeout;
int32 __CFUNC DAQmxGetWatchdogTimeout(TaskHandle taskHandle, float64 *data);
%rename(SetWatchdogTimeout) DAQmxSetWatchdogTimeout;
int32 __CFUNC DAQmxSetWatchdogTimeout(TaskHandle taskHandle, float64 data);
%rename(ResetWatchdogTimeout) DAQmxResetWatchdogTimeout;
int32 __CFUNC DAQmxResetWatchdogTimeout(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_FirstTerm
 ***/
%rename(GetCITwoEdgeSepFirstTerm) DAQmxGetCITwoEdgeSepFirstTerm;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCITwoEdgeSepFirstTerm) DAQmxSetCITwoEdgeSepFirstTerm;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCITwoEdgeSepFirstTerm) DAQmxResetCITwoEdgeSepFirstTerm;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AdvTrig_Type Uses value set
 *** TriggerType5
 ***/
%rename(GetAdvTrigType) DAQmxGetAdvTrigType;
int32 __CFUNC DAQmxGetAdvTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetAdvTrigType) DAQmxSetAdvTrigType;
int32 __CFUNC DAQmxSetAdvTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetAdvTrigType) DAQmxResetAdvTrigType;
int32 __CFUNC DAQmxResetAdvTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SwitchDev_NumSwitchChans
 ***/
%rename(GetSwitchDevNumSwitchChans) DAQmxGetSwitchDevNumSwitchChans;
int32 __CFUNC DAQmxGetSwitchDevNumSwitchChans(const char deviceName[], uInt32 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_HasValidCalInfo
 ***/
%rename(GetAIChanCalHasValidCalInfo) DAQmxGetAIChanCalHasValidCalInfo;
int32 __CFUNC DAQmxGetAIChanCalHasValidCalInfo(TaskHandle taskHandle, const char channel[], bool32 *data);
/*** Set/Get functions for
 *** DAQmx_AI_EddyCurrentProxProbe_SensitivityUnits Uses value set
 *** EddyCurrentProxProbeSensitivityUnits
 ***/
%rename(GetAIEddyCurrentProxProbeSensitivityUnits) DAQmxGetAIEddyCurrentProxProbeSensitivityUnits;
int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIEddyCurrentProxProbeSensitivityUnits) DAQmxSetAIEddyCurrentProxProbeSensitivityUnits;
int32 __CFUNC DAQmxSetAIEddyCurrentProxProbeSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIEddyCurrentProxProbeSensitivityUnits) DAQmxResetAIEddyCurrentProxProbeSensitivityUnits;
int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeSensitivityUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_BInput_DigFltr_TimebaseSrc
 ***/
%rename(GetCIEncoderBInputDigFltrTimebaseSrc) DAQmxGetCIEncoderBInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderBInputDigFltrTimebaseSrc) DAQmxSetCIEncoderBInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIEncoderBInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderBInputDigFltrTimebaseSrc) DAQmxResetCIEncoderBInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_DI_PortWidth
 ***/
%rename(GetPhysicalChanDIPortWidth) DAQmxGetPhysicalChanDIPortWidth;
int32 __CFUNC DAQmxGetPhysicalChanDIPortWidth(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_Write_OpenCurrentLoopChansExist
 ***/
%rename(GetWriteOpenCurrentLoopChansExist) DAQmxGetWriteOpenCurrentLoopChansExist;
int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_CO_Pulse_Ticks_InitialDelay
 ***/
%rename(GetCOPulseTicksInitialDelay) DAQmxGetCOPulseTicksInitialDelay;
int32 __CFUNC DAQmxGetCOPulseTicksInitialDelay(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOPulseTicksInitialDelay) DAQmxSetCOPulseTicksInitialDelay;
int32 __CFUNC DAQmxSetCOPulseTicksInitialDelay(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOPulseTicksInitialDelay) DAQmxResetCOPulseTicksInitialDelay;
int32 __CFUNC DAQmxResetCOPulseTicksInitialDelay(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CO_PhysicalChans
 ***/
%rename(GetDevCOPhysicalChans) DAQmxGetDevCOPhysicalChans;
int32 __CFUNC DAQmxGetDevCOPhysicalChans(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AnlgEdge_RefTrig_Coupling Uses value
 *** set Coupling2
 ***/
%rename(GetAnlgEdgeRefTrigCoupling) DAQmxGetAnlgEdgeRefTrigCoupling;
int32 __CFUNC DAQmxGetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgEdgeRefTrigCoupling) DAQmxSetAnlgEdgeRefTrigCoupling;
int32 __CFUNC DAQmxSetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgEdgeRefTrigCoupling) DAQmxResetAnlgEdgeRefTrigCoupling;
int32 __CFUNC DAQmxResetAnlgEdgeRefTrigCoupling(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_UseOnlyOnBrdMem
 ***/
%rename(GetAOUseOnlyOnBrdMem) DAQmxGetAOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxGetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAOUseOnlyOnBrdMem) DAQmxSetAOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxSetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAOUseOnlyOnBrdMem) DAQmxResetAOUseOnlyOnBrdMem;
int32 __CFUNC DAQmxResetAOUseOnlyOnBrdMem(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AI_CurrentIntExcitDiscreteVals
 ***/
%rename(GetDevAICurrentIntExcitDiscreteVals) DAQmxGetDevAICurrentIntExcitDiscreteVals;
int32 __CFUNC DAQmxGetDevAICurrentIntExcitDiscreteVals(const char device[], float64 *data, uInt32 arraySizeInSamples);

/*** Set/Get functions for DAQmx_Exported_HshkEvent_Pulse_Width
 ***/
%rename(GetExportedHshkEventPulseWidth) DAQmxGetExportedHshkEventPulseWidth;
int32 __CFUNC DAQmxGetExportedHshkEventPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetExportedHshkEventPulseWidth) DAQmxSetExportedHshkEventPulseWidth;
int32 __CFUNC DAQmxSetExportedHshkEventPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetExportedHshkEventPulseWidth) DAQmxResetExportedHshkEventPulseWidth;
int32 __CFUNC DAQmxResetExportedHshkEventPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_StartTrig_Pulse_Polarity
 *** Uses value set Polarity2
 ***/
%rename(GetExportedStartTrigPulsePolarity) DAQmxGetExportedStartTrigPulsePolarity;
int32 __CFUNC DAQmxGetExportedStartTrigPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedStartTrigPulsePolarity) DAQmxSetExportedStartTrigPulsePolarity;
int32 __CFUNC DAQmxSetExportedStartTrigPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedStartTrigPulsePolarity) DAQmxResetExportedStartTrigPulsePolarity;
int32 __CFUNC DAQmxResetExportedStartTrigPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_Pulse_HighTicks
 ***/
%rename(GetCOPulseHighTicks) DAQmxGetCOPulseHighTicks;
int32 __CFUNC DAQmxGetCOPulseHighTicks(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOPulseHighTicks) DAQmxSetCOPulseHighTicks;
int32 __CFUNC DAQmxSetCOPulseHighTicks(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOPulseHighTicks) DAQmxResetCOPulseHighTicks;
int32 __CFUNC DAQmxResetCOPulseHighTicks(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_ProductCategory Uses value set
 *** ProductCategory
 ***/
%rename(GetDevProductCategory) DAQmxGetDevProductCategory;
int32 __CFUNC DAQmxGetDevProductCategory(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_Read_TotalSampPerChanAcquired
 ***/
%rename(GetReadTotalSampPerChanAcquired) DAQmxGetReadTotalSampPerChanAcquired;
int32 __CFUNC DAQmxGetReadTotalSampPerChanAcquired(TaskHandle taskHandle, uInt64 *data);
/*** Set/Get functions for
 *** DAQmx_DigEdge_ArmStartTrig_DigFltr_MinPulseWidth
 ***/
%rename(GetDigEdgeArmStartTrigDigFltrMinPulseWidth) DAQmxGetDigEdgeArmStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetDigEdgeArmStartTrigDigFltrMinPulseWidth) DAQmxSetDigEdgeArmStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetDigEdgeArmStartTrigDigFltrMinPulseWidth) DAQmxResetDigEdgeArmStartTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigDigFltrMinPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SwitchChan_WireMode
 ***/
%rename(GetSwitchChanWireMode) DAQmxGetSwitchChanWireMode;
int32 __CFUNC DAQmxGetSwitchChanWireMode(const char switchChannelName[], uInt32 *data);
/*** Set/Get functions for DAQmx_RefTrig_AutoTrigEnable
 ***/
%rename(GetRefTrigAutoTrigEnable) DAQmxGetRefTrigAutoTrigEnable;
int32 __CFUNC DAQmxGetRefTrigAutoTrigEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetRefTrigAutoTrigEnable) DAQmxSetRefTrigAutoTrigEnable;
int32 __CFUNC DAQmxSetRefTrigAutoTrigEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetRefTrigAutoTrigEnable) DAQmxResetRefTrigAutoTrigEnable;
int32 __CFUNC DAQmxResetRefTrigAutoTrigEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_SoundPressure_Units Uses value set
 *** SoundPressureUnits1
 ***/
%rename(GetAISoundPressureUnits) DAQmxGetAISoundPressureUnits;
int32 __CFUNC DAQmxGetAISoundPressureUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAISoundPressureUnits) DAQmxSetAISoundPressureUnits;
int32 __CFUNC DAQmxSetAISoundPressureUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAISoundPressureUnits) DAQmxResetAISoundPressureUnits;
int32 __CFUNC DAQmxResetAISoundPressureUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_SoundPressure_MaxSoundPressureLvl
 ***/
%rename(GetAISoundPressureMaxSoundPressureLvl) DAQmxGetAISoundPressureMaxSoundPressureLvl;
int32 __CFUNC DAQmxGetAISoundPressureMaxSoundPressureLvl(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAISoundPressureMaxSoundPressureLvl) DAQmxSetAISoundPressureMaxSoundPressureLvl;
int32 __CFUNC DAQmxSetAISoundPressureMaxSoundPressureLvl(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAISoundPressureMaxSoundPressureLvl) DAQmxResetAISoundPressureMaxSoundPressureLvl;
int32 __CFUNC DAQmxResetAISoundPressureMaxSoundPressureLvl(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Period_DigFltr_TimebaseSrc
 ***/
%rename(GetCIPeriodDigFltrTimebaseSrc) DAQmxGetCIPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIPeriodDigFltrTimebaseSrc) DAQmxSetCIPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIPeriodDigFltrTimebaseSrc) DAQmxResetCIPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_DigFltr_TimebaseRate
 ***/
%rename(GetCISemiPeriodDigFltrTimebaseRate) DAQmxGetCISemiPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCISemiPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCISemiPeriodDigFltrTimebaseRate) DAQmxSetCISemiPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCISemiPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCISemiPeriodDigFltrTimebaseRate) DAQmxResetCISemiPeriodDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_First_DigFltr_TimebaseSrc
 ***/
%rename(GetCITwoEdgeSepFirstDigFltrTimebaseSrc) DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCITwoEdgeSepFirstDigFltrTimebaseSrc) DAQmxSetCITwoEdgeSepFirstDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCITwoEdgeSepFirstDigFltrTimebaseSrc) DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Lin_Slope
 ***/
%rename(GetScaleLinSlope) DAQmxGetScaleLinSlope;
int32 __CFUNC DAQmxGetScaleLinSlope(const char scaleName[], float64 *data);
%rename(SetScaleLinSlope) DAQmxSetScaleLinSlope;
int32 __CFUNC DAQmxSetScaleLinSlope(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_AO_DAC_Ref_AllowConnToGnd
 ***/
%rename(GetAODACRefAllowConnToGnd) DAQmxGetAODACRefAllowConnToGnd;
int32 __CFUNC DAQmxGetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAODACRefAllowConnToGnd) DAQmxSetAODACRefAllowConnToGnd;
int32 __CFUNC DAQmxSetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAODACRefAllowConnToGnd) DAQmxResetAODACRefAllowConnToGnd;
int32 __CFUNC DAQmxResetAODACRefAllowConnToGnd(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_ConstrainedGenMode Uses value set
 *** ConstrainedGenMode
 ***/
%rename(GetCOConstrainedGenMode) DAQmxGetCOConstrainedGenMode;
int32 __CFUNC DAQmxGetCOConstrainedGenMode(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCOConstrainedGenMode) DAQmxSetCOConstrainedGenMode;
int32 __CFUNC DAQmxSetCOConstrainedGenMode(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCOConstrainedGenMode) DAQmxResetCOConstrainedGenMode;
int32 __CFUNC DAQmxResetCOConstrainedGenMode(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_CtrOutEvent_Toggle_IdleState
 *** Uses value set Level1
 ***/
%rename(GetExportedCtrOutEventToggleIdleState) DAQmxGetExportedCtrOutEventToggleIdleState;
int32 __CFUNC DAQmxGetExportedCtrOutEventToggleIdleState(TaskHandle taskHandle, int32 *data);
%rename(SetExportedCtrOutEventToggleIdleState) DAQmxSetExportedCtrOutEventToggleIdleState;
int32 __CFUNC DAQmxSetExportedCtrOutEventToggleIdleState(TaskHandle taskHandle, int32 data);
%rename(ResetExportedCtrOutEventToggleIdleState) DAQmxResetExportedCtrOutEventToggleIdleState;
int32 __CFUNC DAQmxResetExportedCtrOutEventToggleIdleState(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Encoder_ZIndexVal
 ***/
%rename(GetCIEncoderZIndexVal) DAQmxGetCIEncoderZIndexVal;
int32 __CFUNC DAQmxGetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderZIndexVal) DAQmxSetCIEncoderZIndexVal;
int32 __CFUNC DAQmxSetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderZIndexVal) DAQmxResetCIEncoderZIndexVal;
int32 __CFUNC DAQmxResetCIEncoderZIndexVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AIConv_TimebaseDiv
 ***/
%rename(GetAIConvTimebaseDiv) DAQmxGetAIConvTimebaseDiv;
int32 __CFUNC DAQmxGetAIConvTimebaseDiv(TaskHandle taskHandle, uInt32 *data);
%rename(SetAIConvTimebaseDiv) DAQmxSetAIConvTimebaseDiv;
int32 __CFUNC DAQmxSetAIConvTimebaseDiv(TaskHandle taskHandle, uInt32 data);
%rename(ResetAIConvTimebaseDiv) DAQmxResetAIConvTimebaseDiv;
int32 __CFUNC DAQmxResetAIConvTimebaseDiv(TaskHandle taskHandle);
%rename(GetAIConvTimebaseDivEx) DAQmxGetAIConvTimebaseDivEx;
int32 __CFUNC DAQmxGetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[], uInt32 *data);
%rename(SetAIConvTimebaseDivEx) DAQmxSetAIConvTimebaseDivEx;
int32 __CFUNC DAQmxSetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[], uInt32 data);
%rename(ResetAIConvTimebaseDivEx) DAQmxResetAIConvTimebaseDivEx;
int32 __CFUNC DAQmxResetAIConvTimebaseDivEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_AI_RTD_R0
 ***/
%rename(GetAIRTDR0) DAQmxGetAIRTDR0;
int32 __CFUNC DAQmxGetAIRTDR0(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRTDR0) DAQmxSetAIRTDR0;
int32 __CFUNC DAQmxSetAIRTDR0(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRTDR0) DAQmxResetAIRTDR0;
int32 __CFUNC DAQmxResetAIRTDR0(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DI_UsbXferReqSize
 ***/
%rename(GetDIUsbXferReqSize) DAQmxGetDIUsbXferReqSize;
int32 __CFUNC DAQmxGetDIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetDIUsbXferReqSize) DAQmxSetDIUsbXferReqSize;
int32 __CFUNC DAQmxSetDIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetDIUsbXferReqSize) DAQmxResetDIUsbXferReqSize;
int32 __CFUNC DAQmxResetDIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Excit_Val
 ***/
%rename(GetAIExcitVal) DAQmxGetAIExcitVal;
int32 __CFUNC DAQmxGetAIExcitVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIExcitVal) DAQmxSetAIExcitVal;
int32 __CFUNC DAQmxSetAIExcitVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIExcitVal) DAQmxResetAIExcitVal;
int32 __CFUNC DAQmxResetAIExcitVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_ProductNum
 ***/
%rename(GetDevProductNum) DAQmxGetDevProductNum;
int32 __CFUNC DAQmxGetDevProductNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_Write_PowerSupplyFaultChansExist
 ***/
%rename(GetWritePowerSupplyFaultChansExist) DAQmxGetWritePowerSupplyFaultChansExist;
int32 __CFUNC DAQmxGetWritePowerSupplyFaultChansExist(TaskHandle taskHandle, bool32 *data);
/*** Physical Channel Set/Get functions for
 *** DAQmx_PhysicalChan_AI_TermCfgs Uses bits from enum
 *** TerminalConfigurationBits
 ***/
%rename(GetPhysicalChanAITermCfgs) DAQmxGetPhysicalChanAITermCfgs;
int32 __CFUNC DAQmxGetPhysicalChanAITermCfgs(const char physicalChannel[], int32 *data);
/*** Set/Get functions for DAQmx_Write_SleepTime
 ***/
%rename(GetWriteSleepTime) DAQmxGetWriteSleepTime;
int32 __CFUNC DAQmxGetWriteSleepTime(TaskHandle taskHandle, float64 *data);
%rename(SetWriteSleepTime) DAQmxSetWriteSleepTime;
int32 __CFUNC DAQmxSetWriteSleepTime(TaskHandle taskHandle, float64 data);
%rename(ResetWriteSleepTime) DAQmxResetWriteSleepTime;
int32 __CFUNC DAQmxResetWriteSleepTime(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_Overcurrent_ReenablePeriod
 ***/
%rename(GetDOOvercurrentReenablePeriod) DAQmxGetDOOvercurrentReenablePeriod;
int32 __CFUNC DAQmxGetDOOvercurrentReenablePeriod(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetDOOvercurrentReenablePeriod) DAQmxSetDOOvercurrentReenablePeriod;
int32 __CFUNC DAQmxSetDOOvercurrentReenablePeriod(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetDOOvercurrentReenablePeriod) DAQmxResetDOOvercurrentReenablePeriod;
int32 __CFUNC DAQmxResetDOOvercurrentReenablePeriod(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_TCPIP_EthernetIP
 ***/
%rename(GetDevTCPIPEthernetIP) DAQmxGetDevTCPIPEthernetIP;
int32 __CFUNC DAQmxGetDevTCPIPEthernetIP(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_SampClk_DigFltr_TimebaseRate
 ***/
%rename(GetSampClkDigFltrTimebaseRate) DAQmxGetSampClkDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetSampClkDigFltrTimebaseRate) DAQmxSetSampClkDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetSampClkDigFltrTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetSampClkDigFltrTimebaseRate) DAQmxResetSampClkDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetSampClkDigFltrTimebaseRate(TaskHandle taskHandle);
/*** Calibration Info Set/Get functions for DAQmx_SelfCal_Supported
 ***/
%rename(GetSelfCalSupported) DAQmxGetSelfCalSupported;
int32 __CFUNC DAQmxGetSelfCalSupported(const char deviceName[], bool32 *data);
/*** Set/Get functions for DAQmx_AI_Voltage_ACRMS_Units Uses value set
 *** VoltageUnits1
 ***/
%rename(GetAIVoltageACRMSUnits) DAQmxGetAIVoltageACRMSUnits;
int32 __CFUNC DAQmxGetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIVoltageACRMSUnits) DAQmxSetAIVoltageACRMSUnits;
int32 __CFUNC DAQmxSetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIVoltageACRMSUnits) DAQmxResetAIVoltageACRMSUnits;
int32 __CFUNC DAQmxResetAIVoltageACRMSUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Resolution
 ***/
%rename(GetAIResolution) DAQmxGetAIResolution;
int32 __CFUNC DAQmxGetAIResolution(TaskHandle taskHandle, const char channel[], float64 *data);
/*** Set/Get functions for DAQmx_CI_Period_Units Uses value set
 *** TimeUnits3
 ***/
%rename(GetCIPeriodUnits) DAQmxGetCIPeriodUnits;
int32 __CFUNC DAQmxGetCIPeriodUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIPeriodUnits) DAQmxSetCIPeriodUnits;
int32 __CFUNC DAQmxSetCIPeriodUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIPeriodUnits) DAQmxResetCIPeriodUnits;
int32 __CFUNC DAQmxResetCIPeriodUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_MasterTimebase_Rate
 ***/
%rename(GetMasterTimebaseRate) DAQmxGetMasterTimebaseRate;
int32 __CFUNC DAQmxGetMasterTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetMasterTimebaseRate) DAQmxSetMasterTimebaseRate;
int32 __CFUNC DAQmxSetMasterTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetMasterTimebaseRate) DAQmxResetMasterTimebaseRate;
int32 __CFUNC DAQmxResetMasterTimebaseRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_TotalSampPerChanGenerated
 ***/
%rename(GetWriteTotalSampPerChanGenerated) DAQmxGetWriteTotalSampPerChanGenerated;
int32 __CFUNC DAQmxGetWriteTotalSampPerChanGenerated(TaskHandle taskHandle, uInt64 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_Verif_RefVals
 ***/
%rename(GetAIChanCalVerifRefVals) DAQmxGetAIChanCalVerifRefVals;
int32 __CFUNC DAQmxGetAIChanCalVerifRefVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalVerifRefVals) DAQmxSetAIChanCalVerifRefVals;
int32 __CFUNC DAQmxSetAIChanCalVerifRefVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalVerifRefVals) DAQmxResetAIChanCalVerifRefVals;
int32 __CFUNC DAQmxResetAIChanCalVerifRefVals(TaskHandle taskHandle, const char channel[]);
/*** Trigger Set/Get functions for DAQmx_StartTrig_Type Uses value set
 *** TriggerType8
 ***/
%rename(GetStartTrigType) DAQmxGetStartTrigType;
int32 __CFUNC DAQmxGetStartTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetStartTrigType) DAQmxSetStartTrigType;
int32 __CFUNC DAQmxSetStartTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetStartTrigType) DAQmxResetStartTrigType;
int32 __CFUNC DAQmxResetStartTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_PhysicalChans
 ***/
%rename(GetDevAIPhysicalChans) DAQmxGetDevAIPhysicalChans;
int32 __CFUNC DAQmxGetDevAIPhysicalChans(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AI_ProbeAtten
 ***/
%rename(GetAIProbeAtten) DAQmxGetAIProbeAtten;
int32 __CFUNC DAQmxGetAIProbeAtten(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIProbeAtten) DAQmxSetAIProbeAtten;
int32 __CFUNC DAQmxSetAIProbeAtten(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIProbeAtten) DAQmxResetAIProbeAtten;
int32 __CFUNC DAQmxResetAIProbeAtten(TaskHandle taskHandle, const char channel[]);
/*** Switch Scan Set/Get functions for DAQmx_SwitchScan_BreakMode Uses
 *** value set BreakMode
 ***/
%rename(GetSwitchScanBreakMode) DAQmxGetSwitchScanBreakMode;
int32 __CFUNC DAQmxGetSwitchScanBreakMode(TaskHandle taskHandle, int32 *data);
%rename(SetSwitchScanBreakMode) DAQmxSetSwitchScanBreakMode;
int32 __CFUNC DAQmxSetSwitchScanBreakMode(TaskHandle taskHandle, int32 data);
%rename(ResetSwitchScanBreakMode) DAQmxResetSwitchScanBreakMode;
int32 __CFUNC DAQmxResetSwitchScanBreakMode(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_DigEdge_StartTrig_DigFltr_TimebaseRate
 ***/
%rename(GetDigEdgeStartTrigDigFltrTimebaseRate) DAQmxGetDigEdgeStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetDigEdgeStartTrigDigFltrTimebaseRate) DAQmxSetDigEdgeStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetDigEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetDigEdgeStartTrigDigFltrTimebaseRate) DAQmxResetDigEdgeStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetDigEdgeStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_HshkTrig_Type Uses value set
 *** TriggerType9
 ***/
%rename(GetHshkTrigType) DAQmxGetHshkTrigType;
int32 __CFUNC DAQmxGetHshkTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetHshkTrigType) DAQmxSetHshkTrigType;
int32 __CFUNC DAQmxSetHshkTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetHshkTrigType) DAQmxResetHshkTrigType;
int32 __CFUNC DAQmxResetHshkTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DelayFromSampClk_DelayUnits Uses
 *** value set DigitalWidthUnits2
 ***/
%rename(GetDelayFromSampClkDelayUnits) DAQmxGetDelayFromSampClkDelayUnits;
int32 __CFUNC DAQmxGetDelayFromSampClkDelayUnits(TaskHandle taskHandle, int32 *data);
%rename(SetDelayFromSampClkDelayUnits) DAQmxSetDelayFromSampClkDelayUnits;
int32 __CFUNC DAQmxSetDelayFromSampClkDelayUnits(TaskHandle taskHandle, int32 data);
%rename(ResetDelayFromSampClkDelayUnits) DAQmxResetDelayFromSampClkDelayUnits;
int32 __CFUNC DAQmxResetDelayFromSampClkDelayUnits(TaskHandle taskHandle);
%rename(GetDelayFromSampClkDelayUnitsEx) DAQmxGetDelayFromSampClkDelayUnitsEx;
int32 __CFUNC DAQmxGetDelayFromSampClkDelayUnitsEx(TaskHandle taskHandle, const char deviceNames[], int32 *data);
%rename(SetDelayFromSampClkDelayUnitsEx) DAQmxSetDelayFromSampClkDelayUnitsEx;
int32 __CFUNC DAQmxSetDelayFromSampClkDelayUnitsEx(TaskHandle taskHandle, const char deviceNames[], int32 data);
%rename(ResetDelayFromSampClkDelayUnitsEx) DAQmxResetDelayFromSampClkDelayUnitsEx;
int32 __CFUNC DAQmxResetDelayFromSampClkDelayUnitsEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_AnlgWin_StartTrig_Src
 ***/
%rename(GetAnlgWinStartTrigSrc) DAQmxGetAnlgWinStartTrigSrc;
int32 __CFUNC DAQmxGetAnlgWinStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgWinStartTrigSrc) DAQmxSetAnlgWinStartTrigSrc;
int32 __CFUNC DAQmxSetAnlgWinStartTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgWinStartTrigSrc) DAQmxResetAnlgWinStartTrigSrc;
int32 __CFUNC DAQmxResetAnlgWinStartTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AO_SampClkSupported
 ***/
%rename(GetDevAOSampClkSupported) DAQmxGetDevAOSampClkSupported;
int32 __CFUNC DAQmxGetDevAOSampClkSupported(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_Cal_UserDefinedInfo_MaxSize
 ***/
%rename(GetCalUserDefinedInfoMaxSize) DAQmxGetCalUserDefinedInfoMaxSize;
int32 __CFUNC DAQmxGetCalUserDefinedInfoMaxSize(const char deviceName[], uInt32 *data);
/*** Read Set/Get functions for DAQmx_Read_RelativeTo Uses value set
 *** ReadRelativeTo
 ***/
%rename(GetReadRelativeTo) DAQmxGetReadRelativeTo;
int32 __CFUNC DAQmxGetReadRelativeTo(TaskHandle taskHandle, int32 *data);
%rename(SetReadRelativeTo) DAQmxSetReadRelativeTo;
int32 __CFUNC DAQmxSetReadRelativeTo(TaskHandle taskHandle, int32 data);
%rename(ResetReadRelativeTo) DAQmxResetReadRelativeTo;
int32 __CFUNC DAQmxResetReadRelativeTo(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AO_VoltageRngs
 ***/
%rename(GetDevAOVoltageRngs) DAQmxGetDevAOVoltageRngs;
int32 __CFUNC DAQmxGetDevAOVoltageRngs(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_InputSrc
 ***/
%rename(GetAIInputSrc) DAQmxGetAIInputSrc;
int32 __CFUNC DAQmxGetAIInputSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAIInputSrc) DAQmxSetAIInputSrc;
int32 __CFUNC DAQmxSetAIInputSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAIInputSrc) DAQmxResetAIInputSrc;
int32 __CFUNC DAQmxResetAIInputSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_RdyForXferEvent_OutputTerm
 ***/
%rename(GetExportedRdyForXferEventOutputTerm) DAQmxGetExportedRdyForXferEventOutputTerm;
int32 __CFUNC DAQmxGetExportedRdyForXferEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedRdyForXferEventOutputTerm) DAQmxSetExportedRdyForXferEventOutputTerm;
int32 __CFUNC DAQmxSetExportedRdyForXferEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedRdyForXferEventOutputTerm) DAQmxResetExportedRdyForXferEventOutputTerm;
int32 __CFUNC DAQmxResetExportedRdyForXferEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgWin_RefTrig_Top
 ***/
%rename(GetAnlgWinRefTrigTop) DAQmxGetAnlgWinRefTrigTop;
int32 __CFUNC DAQmxGetAnlgWinRefTrigTop(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinRefTrigTop) DAQmxSetAnlgWinRefTrigTop;
int32 __CFUNC DAQmxSetAnlgWinRefTrigTop(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinRefTrigTop) DAQmxResetAnlgWinRefTrigTop;
int32 __CFUNC DAQmxResetAnlgWinRefTrigTop(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Freq_Units Uses value set
 *** FrequencyUnits3
 ***/
%rename(GetCIFreqUnits) DAQmxGetCIFreqUnits;
int32 __CFUNC DAQmxGetCIFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIFreqUnits) DAQmxSetCIFreqUnits;
int32 __CFUNC DAQmxSetCIFreqUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIFreqUnits) DAQmxResetCIFreqUnits;
int32 __CFUNC DAQmxResetCIFreqUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Write_RawDataWidth
 ***/
%rename(GetWriteRawDataWidth) DAQmxGetWriteRawDataWidth;
int32 __CFUNC DAQmxGetWriteRawDataWidth(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_CI_Freq_MeasMeth Uses value set
 *** CounterFrequencyMethod
 ***/
%rename(GetCIFreqMeasMeth) DAQmxGetCIFreqMeasMeth;
int32 __CFUNC DAQmxGetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIFreqMeasMeth) DAQmxSetCIFreqMeasMeth;
int32 __CFUNC DAQmxSetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIFreqMeasMeth) DAQmxResetCIFreqMeasMeth;
int32 __CFUNC DAQmxResetCIFreqMeasMeth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CompactDAQ_SlotNum
 ***/
%rename(GetDevCompactDAQSlotNum) DAQmxGetDevCompactDAQSlotNum;
int32 __CFUNC DAQmxGetDevCompactDAQSlotNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_CO_Count
 ***/
%rename(GetCOCount) DAQmxGetCOCount;
int32 __CFUNC DAQmxGetCOCount(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_CountEdges_CountDir_DigSync_Enable
 ***/
%rename(GetCICountEdgesCountDirDigSyncEnable) DAQmxGetCICountEdgesCountDirDigSyncEnable;
int32 __CFUNC DAQmxGetCICountEdgesCountDirDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICountEdgesCountDirDigSyncEnable) DAQmxSetCICountEdgesCountDirDigSyncEnable;
int32 __CFUNC DAQmxSetCICountEdgesCountDirDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICountEdgesCountDirDigSyncEnable) DAQmxResetCICountEdgesCountDirDigSyncEnable;
int32 __CFUNC DAQmxResetCICountEdgesCountDirDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_Exported_HshkEvent_Interlocked_DeassertDelay
 ***/
%rename(GetExportedHshkEventInterlockedDeassertDelay) DAQmxGetExportedHshkEventInterlockedDeassertDelay;
int32 __CFUNC DAQmxGetExportedHshkEventInterlockedDeassertDelay(TaskHandle taskHandle, float64 *data);
%rename(SetExportedHshkEventInterlockedDeassertDelay) DAQmxSetExportedHshkEventInterlockedDeassertDelay;
int32 __CFUNC DAQmxSetExportedHshkEventInterlockedDeassertDelay(TaskHandle taskHandle, float64 data);
%rename(ResetExportedHshkEventInterlockedDeassertDelay) DAQmxResetExportedHshkEventInterlockedDeassertDelay;
int32 __CFUNC DAQmxResetExportedHshkEventInterlockedDeassertDelay(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SwitchChan_MaxACSwitchPwr
 ***/
%rename(GetSwitchChanMaxACSwitchPwr) DAQmxGetSwitchChanMaxACSwitchPwr;
int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchPwr(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_Excit_UseForScaling
 ***/
%rename(GetAIExcitUseForScaling) DAQmxGetAIExcitUseForScaling;
int32 __CFUNC DAQmxGetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIExcitUseForScaling) DAQmxSetAIExcitUseForScaling;
int32 __CFUNC DAQmxSetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIExcitUseForScaling) DAQmxResetAIExcitUseForScaling;
int32 __CFUNC DAQmxResetAIExcitUseForScaling(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_ArmStartTrig_Edge Uses value
 *** set Edge1
 ***/
%rename(GetDigEdgeArmStartTrigEdge) DAQmxGetDigEdgeArmStartTrigEdge;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigEdge(TaskHandle taskHandle, int32 *data);
%rename(SetDigEdgeArmStartTrigEdge) DAQmxSetDigEdgeArmStartTrigEdge;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigEdge(TaskHandle taskHandle, int32 data);
%rename(ResetDigEdgeArmStartTrigEdge) DAQmxResetDigEdgeArmStartTrigEdge;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_OvercurrentChansExist
 ***/
%rename(GetWriteOvercurrentChansExist) DAQmxGetWriteOvercurrentChansExist;
int32 __CFUNC DAQmxGetWriteOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_Dev_CO_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevCOTrigUsage) DAQmxGetDevCOTrigUsage;
int32 __CFUNC DAQmxGetDevCOTrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_Poly_ForwardCoeff
 ***/
%rename(GetAIChanCalPolyForwardCoeff) DAQmxGetAIChanCalPolyForwardCoeff;
int32 __CFUNC DAQmxGetAIChanCalPolyForwardCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalPolyForwardCoeff) DAQmxSetAIChanCalPolyForwardCoeff;
int32 __CFUNC DAQmxSetAIChanCalPolyForwardCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalPolyForwardCoeff) DAQmxResetAIChanCalPolyForwardCoeff;
int32 __CFUNC DAQmxResetAIChanCalPolyForwardCoeff(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_SyncPulseEvent_OutputTerm
 ***/
%rename(GetExportedSyncPulseEventOutputTerm) DAQmxGetExportedSyncPulseEventOutputTerm;
int32 __CFUNC DAQmxGetExportedSyncPulseEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedSyncPulseEventOutputTerm) DAQmxSetExportedSyncPulseEventOutputTerm;
int32 __CFUNC DAQmxSetExportedSyncPulseEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedSyncPulseEventOutputTerm) DAQmxResetExportedSyncPulseEventOutputTerm;
int32 __CFUNC DAQmxResetExportedSyncPulseEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_ACExcit_Freq
 ***/
%rename(GetAIACExcitFreq) DAQmxGetAIACExcitFreq;
int32 __CFUNC DAQmxGetAIACExcitFreq(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIACExcitFreq) DAQmxSetAIACExcitFreq;
int32 __CFUNC DAQmxSetAIACExcitFreq(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIACExcitFreq) DAQmxResetAIACExcitFreq;
int32 __CFUNC DAQmxResetAIACExcitFreq(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_PersistedScale_AllowInteractiveEditing
 ***/
%rename(GetPersistedScaleAllowInteractiveEditing) DAQmxGetPersistedScaleAllowInteractiveEditing;
int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveEditing(const char scaleName[], bool32 *data);
/*** Set/Get functions for DAQmx_SyncPulse_MinDelayToStart
 ***/
%rename(GetSyncPulseMinDelayToStart) DAQmxGetSyncPulseMinDelayToStart;
int32 __CFUNC DAQmxGetSyncPulseMinDelayToStart(TaskHandle taskHandle, float64 *data);
%rename(SetSyncPulseMinDelayToStart) DAQmxSetSyncPulseMinDelayToStart;
int32 __CFUNC DAQmxSetSyncPulseMinDelayToStart(TaskHandle taskHandle, float64 data);
%rename(ResetSyncPulseMinDelayToStart) DAQmxResetSyncPulseMinDelayToStart;
int32 __CFUNC DAQmxResetSyncPulseMinDelayToStart(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_UsbXferReqSize
 ***/
%rename(GetDOUsbXferReqSize) DAQmxGetDOUsbXferReqSize;
int32 __CFUNC DAQmxGetDOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetDOUsbXferReqSize) DAQmxSetDOUsbXferReqSize;
int32 __CFUNC DAQmxSetDOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetDOUsbXferReqSize) DAQmxResetDOUsbXferReqSize;
int32 __CFUNC DAQmxResetDOUsbXferReqSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_ArmStartTrig_DigSync_Enable
 ***/
%rename(GetDigEdgeArmStartTrigDigSyncEnable) DAQmxGetDigEdgeArmStartTrigDigSyncEnable;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigEdgeArmStartTrigDigSyncEnable) DAQmxSetDigEdgeArmStartTrigDigSyncEnable;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigDigSyncEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigEdgeArmStartTrigDigSyncEnable) DAQmxResetDigEdgeArmStartTrigDigSyncEnable;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigDigSyncEnable(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_AI_MemMapEnable
 ***/
%rename(GetAIMemMapEnable) DAQmxGetAIMemMapEnable;
int32 __CFUNC DAQmxGetAIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIMemMapEnable) DAQmxSetAIMemMapEnable;
int32 __CFUNC DAQmxSetAIMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIMemMapEnable) DAQmxResetAIMemMapEnable;
int32 __CFUNC DAQmxResetAIMemMapEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Excit_DCorAC Uses value set
 *** ExcitationDCorAC
 ***/
%rename(GetAIExcitDCorAC) DAQmxGetAIExcitDCorAC;
int32 __CFUNC DAQmxGetAIExcitDCorAC(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIExcitDCorAC) DAQmxSetAIExcitDCorAC;
int32 __CFUNC DAQmxSetAIExcitDCorAC(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIExcitDCorAC) DAQmxResetAIExcitDCorAC;
int32 __CFUNC DAQmxResetAIExcitDCorAC(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_Term
 ***/
%rename(GetCOPulseTerm) DAQmxGetCOPulseTerm;
int32 __CFUNC DAQmxGetCOPulseTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCOPulseTerm) DAQmxSetCOPulseTerm;
int32 __CFUNC DAQmxSetCOPulseTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCOPulseTerm) DAQmxResetCOPulseTerm;
int32 __CFUNC DAQmxResetCOPulseTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_IdleOutputBehavior Uses value set
 *** AOIdleOutputBehavior
 ***/
%rename(GetAOIdleOutputBehavior) DAQmxGetAOIdleOutputBehavior;
int32 __CFUNC DAQmxGetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOIdleOutputBehavior) DAQmxSetAOIdleOutputBehavior;
int32 __CFUNC DAQmxSetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOIdleOutputBehavior) DAQmxResetAOIdleOutputBehavior;
int32 __CFUNC DAQmxResetAOIdleOutputBehavior(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_RealTime_ReportMissedSamp
 ***/
%rename(GetRealTimeReportMissedSamp) DAQmxGetRealTimeReportMissedSamp;
int32 __CFUNC DAQmxGetRealTimeReportMissedSamp(TaskHandle taskHandle, bool32 *data);
%rename(SetRealTimeReportMissedSamp) DAQmxSetRealTimeReportMissedSamp;
int32 __CFUNC DAQmxSetRealTimeReportMissedSamp(TaskHandle taskHandle, bool32 data);
%rename(ResetRealTimeReportMissedSamp) DAQmxResetRealTimeReportMissedSamp;
int32 __CFUNC DAQmxResetRealTimeReportMissedSamp(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_Pulse_Freq_InitialDelay
 ***/
%rename(GetCOPulseFreqInitialDelay) DAQmxGetCOPulseFreqInitialDelay;
int32 __CFUNC DAQmxGetCOPulseFreqInitialDelay(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseFreqInitialDelay) DAQmxSetCOPulseFreqInitialDelay;
int32 __CFUNC DAQmxSetCOPulseFreqInitialDelay(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseFreqInitialDelay) DAQmxResetCOPulseFreqInitialDelay;
int32 __CFUNC DAQmxResetCOPulseFreqInitialDelay(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_DigSync_Enable
 ***/
%rename(GetCICountEdgesDigSyncEnable) DAQmxGetCICountEdgesDigSyncEnable;
int32 __CFUNC DAQmxGetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICountEdgesDigSyncEnable) DAQmxSetCICountEdgesDigSyncEnable;
int32 __CFUNC DAQmxSetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICountEdgesDigSyncEnable) DAQmxResetCICountEdgesDigSyncEnable;
int32 __CFUNC DAQmxResetCICountEdgesDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_DupCountPrevent
 ***/
%rename(GetCIDupCountPrevent) DAQmxGetCIDupCountPrevent;
int32 __CFUNC DAQmxGetCIDupCountPrevent(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIDupCountPrevent) DAQmxSetCIDupCountPrevent;
int32 __CFUNC DAQmxSetCIDupCountPrevent(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIDupCountPrevent) DAQmxResetCIDupCountPrevent;
int32 __CFUNC DAQmxResetCIDupCountPrevent(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_Freq
 ***/
%rename(GetCOPulseFreq) DAQmxGetCOPulseFreq;
int32 __CFUNC DAQmxGetCOPulseFreq(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseFreq) DAQmxSetCOPulseFreq;
int32 __CFUNC DAQmxSetCOPulseFreq(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseFreq) DAQmxResetCOPulseFreq;
int32 __CFUNC DAQmxResetCOPulseFreq(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_ReglitchEnable
 ***/
%rename(GetAOReglitchEnable) DAQmxGetAOReglitchEnable;
int32 __CFUNC DAQmxGetAOReglitchEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAOReglitchEnable) DAQmxSetAOReglitchEnable;
int32 __CFUNC DAQmxSetAOReglitchEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAOReglitchEnable) DAQmxResetAOReglitchEnable;
int32 __CFUNC DAQmxResetAOReglitchEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Max
 ***/
%rename(GetCIMax) DAQmxGetCIMax;
int32 __CFUNC DAQmxGetCIMax(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIMax) DAQmxSetCIMax;
int32 __CFUNC DAQmxSetCIMax(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIMax) DAQmxResetCIMax;
int32 __CFUNC DAQmxResetCIMax(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_CountDir_DigFltr_Enable
 ***/
%rename(GetCICountEdgesCountDirDigFltrEnable) DAQmxGetCICountEdgesCountDirDigFltrEnable;
int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICountEdgesCountDirDigFltrEnable) DAQmxSetCICountEdgesCountDirDigFltrEnable;
int32 __CFUNC DAQmxSetCICountEdgesCountDirDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICountEdgesCountDirDigFltrEnable) DAQmxResetCICountEdgesCountDirDigFltrEnable;
int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_DO_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevDOTrigUsage) DAQmxGetDevDOTrigUsage;
int32 __CFUNC DAQmxGetDevDOTrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_CI_DataXferMech Uses value set
 *** DataTransferMechanism
 ***/
%rename(GetCIDataXferMech) DAQmxGetCIDataXferMech;
int32 __CFUNC DAQmxGetCIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIDataXferMech) DAQmxSetCIDataXferMech;
int32 __CFUNC DAQmxSetCIDataXferMech(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIDataXferMech) DAQmxResetCIDataXferMech;
int32 __CFUNC DAQmxResetCIDataXferMech(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Bridge_InitialVoltage
 ***/
%rename(GetAIBridgeInitialVoltage) DAQmxGetAIBridgeInitialVoltage;
int32 __CFUNC DAQmxGetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIBridgeInitialVoltage) DAQmxSetAIBridgeInitialVoltage;
int32 __CFUNC DAQmxSetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIBridgeInitialVoltage) DAQmxResetAIBridgeInitialVoltage;
int32 __CFUNC DAQmxResetAIBridgeInitialVoltage(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_Gain
 ***/
%rename(GetAOGain) DAQmxGetAOGain;
int32 __CFUNC DAQmxGetAOGain(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOGain) DAQmxSetAOGain;
int32 __CFUNC DAQmxSetAOGain(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOGain) DAQmxResetAOGain;
int32 __CFUNC DAQmxResetAOGain(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_Units Uses value set
 *** TimeUnits3
 ***/
%rename(GetCISemiPeriodUnits) DAQmxGetCISemiPeriodUnits;
int32 __CFUNC DAQmxGetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCISemiPeriodUnits) DAQmxSetCISemiPeriodUnits;
int32 __CFUNC DAQmxSetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCISemiPeriodUnits) DAQmxResetCISemiPeriodUnits;
int32 __CFUNC DAQmxResetCISemiPeriodUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgEdge_StartTrig_Src
 ***/
%rename(GetAnlgEdgeStartTrigSrc) DAQmxGetAnlgEdgeStartTrigSrc;
int32 __CFUNC DAQmxGetAnlgEdgeStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgEdgeStartTrigSrc) DAQmxSetAnlgEdgeStartTrigSrc;
int32 __CFUNC DAQmxSetAnlgEdgeStartTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgEdgeStartTrigSrc) DAQmxResetAnlgEdgeStartTrigSrc;
int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampClk_Timebase_Rate
 ***/
%rename(GetSampClkTimebaseRate) DAQmxGetSampClkTimebaseRate;
int32 __CFUNC DAQmxGetSampClkTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetSampClkTimebaseRate) DAQmxSetSampClkTimebaseRate;
int32 __CFUNC DAQmxSetSampClkTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetSampClkTimebaseRate) DAQmxResetSampClkTimebaseRate;
int32 __CFUNC DAQmxResetSampClkTimebaseRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Accel_dBRef
 ***/
%rename(GetAIAcceldBRef) DAQmxGetAIAcceldBRef;
int32 __CFUNC DAQmxGetAIAcceldBRef(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIAcceldBRef) DAQmxSetAIAcceldBRef;
int32 __CFUNC DAQmxSetAIAcceldBRef(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIAcceldBRef) DAQmxResetAIAcceldBRef;
int32 __CFUNC DAQmxResetAIAcceldBRef(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_NumPossiblyInvalidSamps
 ***/
%rename(GetCINumPossiblyInvalidSamps) DAQmxGetCINumPossiblyInvalidSamps;
int32 __CFUNC DAQmxGetCINumPossiblyInvalidSamps(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for DAQmx_PersistedTask_AllowInteractiveEditing
 ***/
%rename(GetPersistedTaskAllowInteractiveEditing) DAQmxGetPersistedTaskAllowInteractiveEditing;
int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveEditing(const char taskName[], bool32 *data);
/*** Set/Get functions for DAQmx_Dev_AI_LowpassCutoffFreqDiscreteVals
 ***/
%rename(GetDevAILowpassCutoffFreqDiscreteVals) DAQmxGetDevAILowpassCutoffFreqDiscreteVals;
int32 __CFUNC DAQmxGetDevAILowpassCutoffFreqDiscreteVals(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_DigFltr_TimebaseSrc
 ***/
%rename(GetDigLvlPauseTrigDigFltrTimebaseSrc) DAQmxGetDigLvlPauseTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigLvlPauseTrigDigFltrTimebaseSrc) DAQmxSetDigLvlPauseTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetDigLvlPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigLvlPauseTrigDigFltrTimebaseSrc) DAQmxResetDigLvlPauseTrigDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetDigLvlPauseTrigDigFltrTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_CtrTimebaseMasterTimebaseDiv
 ***/
%rename(GetCOCtrTimebaseMasterTimebaseDiv) DAQmxGetCOCtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxGetCOCtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOCtrTimebaseMasterTimebaseDiv) DAQmxSetCOCtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxSetCOCtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOCtrTimebaseMasterTimebaseDiv) DAQmxResetCOCtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxResetCOCtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_RVDT_Units Uses value set
 *** AngleUnits1
 ***/
%rename(GetAIRVDTUnits) DAQmxGetAIRVDTUnits;
int32 __CFUNC DAQmxGetAIRVDTUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIRVDTUnits) DAQmxSetAIRVDTUnits;
int32 __CFUNC DAQmxSetAIRVDTUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIRVDTUnits) DAQmxResetAIRVDTUnits;
int32 __CFUNC DAQmxResetAIRVDTUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_SerialNum
 ***/
%rename(GetDevSerialNum) DAQmxGetDevSerialNum;
int32 __CFUNC DAQmxGetDevSerialNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_AI_EddyCurrentProxProbe_Units Uses
 *** value set LengthUnits2
 ***/
%rename(GetAIEddyCurrentProxProbeUnits) DAQmxGetAIEddyCurrentProxProbeUnits;
int32 __CFUNC DAQmxGetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIEddyCurrentProxProbeUnits) DAQmxSetAIEddyCurrentProxProbeUnits;
int32 __CFUNC DAQmxSetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIEddyCurrentProxProbeUnits) DAQmxResetAIEddyCurrentProxProbeUnits;
int32 __CFUNC DAQmxResetAIEddyCurrentProxProbeUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_HshkEvent_OutputTerm
 ***/
%rename(GetExportedHshkEventOutputTerm) DAQmxGetExportedHshkEventOutputTerm;
int32 __CFUNC DAQmxGetExportedHshkEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedHshkEventOutputTerm) DAQmxSetExportedHshkEventOutputTerm;
int32 __CFUNC DAQmxSetExportedHshkEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedHshkEventOutputTerm) DAQmxResetExportedHshkEventOutputTerm;
int32 __CFUNC DAQmxResetExportedHshkEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Encoder_ZInput_DigFltr_TimebaseSrc
 ***/
%rename(GetCIEncoderZInputDigFltrTimebaseSrc) DAQmxGetCIEncoderZInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderZInputDigFltrTimebaseSrc) DAQmxSetCIEncoderZInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIEncoderZInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderZInputDigFltrTimebaseSrc) DAQmxResetCIEncoderZInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_RefTrig_When Uses value set
 *** WindowTriggerCondition1
 ***/
%rename(GetAnlgWinRefTrigWhen) DAQmxGetAnlgWinRefTrigWhen;
int32 __CFUNC DAQmxGetAnlgWinRefTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinRefTrigWhen) DAQmxSetAnlgWinRefTrigWhen;
int32 __CFUNC DAQmxSetAnlgWinRefTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinRefTrigWhen) DAQmxResetAnlgWinRefTrigWhen;
int32 __CFUNC DAQmxResetAnlgWinRefTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_OpenThrmcplChans
 ***/
%rename(GetReadOpenThrmcplChans) DAQmxGetReadOpenThrmcplChans;
int32 __CFUNC DAQmxGetReadOpenThrmcplChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_SwitchScan_RepeatMode Uses value set
 *** SwitchScanRepeatMode
 ***/
%rename(GetSwitchScanRepeatMode) DAQmxGetSwitchScanRepeatMode;
int32 __CFUNC DAQmxGetSwitchScanRepeatMode(TaskHandle taskHandle, int32 *data);
%rename(SetSwitchScanRepeatMode) DAQmxSetSwitchScanRepeatMode;
int32 __CFUNC DAQmxSetSwitchScanRepeatMode(TaskHandle taskHandle, int32 data);
%rename(ResetSwitchScanRepeatMode) DAQmxResetSwitchScanRepeatMode;
int32 __CFUNC DAQmxResetSwitchScanRepeatMode(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_ZInput_DigFltr_MinPulseWidth
 ***/
%rename(GetCIEncoderZInputDigFltrMinPulseWidth) DAQmxGetCIEncoderZInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderZInputDigFltrMinPulseWidth) DAQmxSetCIEncoderZInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIEncoderZInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderZInputDigFltrMinPulseWidth) DAQmxResetCIEncoderZInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchChan_MaxDCVoltage
 ***/
%rename(GetSwitchChanMaxDCVoltage) DAQmxGetSwitchChanMaxDCVoltage;
int32 __CFUNC DAQmxGetSwitchChanMaxDCVoltage(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_LVDT_Units Uses value set
 *** LengthUnits2
 ***/
%rename(GetAILVDTUnits) DAQmxGetAILVDTUnits;
int32 __CFUNC DAQmxGetAILVDTUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAILVDTUnits) DAQmxSetAILVDTUnits;
int32 __CFUNC DAQmxSetAILVDTUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAILVDTUnits) DAQmxResetAILVDTUnits;
int32 __CFUNC DAQmxResetAILVDTUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_AO_ManualControlFreq
 ***/
%rename(GetPhysicalChanAOManualControlFreq) DAQmxGetPhysicalChanAOManualControlFreq;
int32 __CFUNC DAQmxGetPhysicalChanAOManualControlFreq(const char physicalChannel[], float64 *data);
/*** Set/Get functions for DAQmx_AI_ADCTimingMode Uses value set
 *** ADCTimingMode
 ***/
%rename(GetAIADCTimingMode) DAQmxGetAIADCTimingMode;
int32 __CFUNC DAQmxGetAIADCTimingMode(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIADCTimingMode) DAQmxSetAIADCTimingMode;
int32 __CFUNC DAQmxSetAIADCTimingMode(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIADCTimingMode) DAQmxResetAIADCTimingMode;
int32 __CFUNC DAQmxResetAIADCTimingMode(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Bridge_NomResistance
 ***/
%rename(GetAIBridgeNomResistance) DAQmxGetAIBridgeNomResistance;
int32 __CFUNC DAQmxGetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIBridgeNomResistance) DAQmxSetAIBridgeNomResistance;
int32 __CFUNC DAQmxSetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIBridgeNomResistance) DAQmxResetAIBridgeNomResistance;
int32 __CFUNC DAQmxResetAIBridgeNomResistance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AO_MinRate
 ***/
%rename(GetDevAOMinRate) DAQmxGetDevAOMinRate;
int32 __CFUNC DAQmxGetDevAOMinRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_SwitchChan_MaxACSwitchCurrent
 ***/
%rename(GetSwitchChanMaxACSwitchCurrent) DAQmxGetSwitchChanMaxACSwitchCurrent;
int32 __CFUNC DAQmxGetSwitchChanMaxACSwitchCurrent(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_Dev_TCPIP_Hostname
 ***/
%rename(GetDevTCPIPHostname) DAQmxGetDevTCPIPHostname;
int32 __CFUNC DAQmxGetDevTCPIPHostname(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_AnlgEdge_RefTrig_Src
 ***/
%rename(GetAnlgEdgeRefTrigSrc) DAQmxGetAnlgEdgeRefTrigSrc;
int32 __CFUNC DAQmxGetAnlgEdgeRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgEdgeRefTrigSrc) DAQmxSetAnlgEdgeRefTrigSrc;
int32 __CFUNC DAQmxSetAnlgEdgeRefTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgEdgeRefTrigSrc) DAQmxResetAnlgEdgeRefTrigSrc;
int32 __CFUNC DAQmxResetAnlgEdgeRefTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_Second_DigFltr_TimebaseSrc
 ***/
%rename(GetCITwoEdgeSepSecondDigFltrTimebaseSrc) DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCITwoEdgeSepSecondDigFltrTimebaseSrc) DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCITwoEdgeSepSecondDigFltrTimebaseSrc) DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AO_MaxRate
 ***/
%rename(GetDevAOMaxRate) DAQmxGetDevAOMaxRate;
int32 __CFUNC DAQmxGetDevAOMaxRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_AI_UsbXferReqSize
 ***/
%rename(GetAIUsbXferReqSize) DAQmxGetAIUsbXferReqSize;
int32 __CFUNC DAQmxGetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAIUsbXferReqSize) DAQmxSetAIUsbXferReqSize;
int32 __CFUNC DAQmxSetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAIUsbXferReqSize) DAQmxResetAIUsbXferReqSize;
int32 __CFUNC DAQmxResetAIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Bridge_ShuntCal_Select Uses value
 *** set ShuntCalSelect
 ***/
%rename(GetAIBridgeShuntCalSelect) DAQmxGetAIBridgeShuntCalSelect;
int32 __CFUNC DAQmxGetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIBridgeShuntCalSelect) DAQmxSetAIBridgeShuntCalSelect;
int32 __CFUNC DAQmxSetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIBridgeShuntCalSelect) DAQmxResetAIBridgeShuntCalSelect;
int32 __CFUNC DAQmxResetAIBridgeShuntCalSelect(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_RelayList
 ***/
%rename(GetSwitchDevRelayList) DAQmxGetSwitchDevRelayList;
int32 __CFUNC DAQmxGetSwitchDevRelayList(const char deviceName[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CI_Freq_DigFltr_TimebaseRate
 ***/
%rename(GetCIFreqDigFltrTimebaseRate) DAQmxGetCIFreqDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIFreqDigFltrTimebaseRate) DAQmxSetCIFreqDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIFreqDigFltrTimebaseRate) DAQmxResetCIFreqDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Timing Set/Get functions for DAQmx_SampQuant_SampMode Uses value
 *** set AcquisitionType
 ***/
%rename(GetSampQuantSampMode) DAQmxGetSampQuantSampMode;
int32 __CFUNC DAQmxGetSampQuantSampMode(TaskHandle taskHandle, int32 *data);
%rename(SetSampQuantSampMode) DAQmxSetSampQuantSampMode;
int32 __CFUNC DAQmxSetSampQuantSampMode(TaskHandle taskHandle, int32 data);
%rename(ResetSampQuantSampMode) DAQmxResetSampQuantSampMode;
int32 __CFUNC DAQmxResetSampQuantSampMode(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Current_Units Uses value set
 *** CurrentUnits1
 ***/
%rename(GetAICurrentUnits) DAQmxGetAICurrentUnits;
int32 __CFUNC DAQmxGetAICurrentUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAICurrentUnits) DAQmxSetAICurrentUnits;
int32 __CFUNC DAQmxSetAICurrentUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAICurrentUnits) DAQmxResetAICurrentUnits;
int32 __CFUNC DAQmxResetAICurrentUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_LowTicks
 ***/
%rename(GetCOPulseLowTicks) DAQmxGetCOPulseLowTicks;
int32 __CFUNC DAQmxGetCOPulseLowTicks(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOPulseLowTicks) DAQmxSetCOPulseLowTicks;
int32 __CFUNC DAQmxSetCOPulseLowTicks(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOPulseLowTicks) DAQmxResetCOPulseLowTicks;
int32 __CFUNC DAQmxResetCOPulseLowTicks(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_VersionNum
 ***/
%rename(GetPhysicalChanTEDSVersionNum) DAQmxGetPhysicalChanTEDSVersionNum;
int32 __CFUNC DAQmxGetPhysicalChanTEDSVersionNum(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_CO_CtrTimebase_DigFltr_TimebaseRate
 ***/
%rename(GetCOCtrTimebaseDigFltrTimebaseRate) DAQmxGetCOCtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCOCtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOCtrTimebaseDigFltrTimebaseRate) DAQmxSetCOCtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCOCtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOCtrTimebaseDigFltrTimebaseRate) DAQmxResetCOCtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCOCtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_Tristate
 ***/
%rename(GetDOTristate) DAQmxGetDOTristate;
int32 __CFUNC DAQmxGetDOTristate(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDOTristate) DAQmxSetDOTristate;
int32 __CFUNC DAQmxSetDOTristate(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDOTristate) DAQmxResetDOTristate;
int32 __CFUNC DAQmxResetDOTristate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_BInput_DigSync_Enable
 ***/
%rename(GetCIEncoderBInputDigSyncEnable) DAQmxGetCIEncoderBInputDigSyncEnable;
int32 __CFUNC DAQmxGetCIEncoderBInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderBInputDigSyncEnable) DAQmxSetCIEncoderBInputDigSyncEnable;
int32 __CFUNC DAQmxSetCIEncoderBInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderBInputDigSyncEnable) DAQmxResetCIEncoderBInputDigSyncEnable;
int32 __CFUNC DAQmxResetCIEncoderBInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_OpenCurrentLoopChans
 ***/
%rename(GetReadOpenCurrentLoopChans) DAQmxGetReadOpenCurrentLoopChans;
int32 __CFUNC DAQmxGetReadOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for
 *** DAQmx_DigEdge_ArmStartTrig_DigFltr_TimebaseRate
 ***/
%rename(GetDigEdgeArmStartTrigDigFltrTimebaseRate) DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetDigEdgeArmStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetDigEdgeArmStartTrigDigFltrTimebaseRate) DAQmxSetDigEdgeArmStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetDigEdgeArmStartTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetDigEdgeArmStartTrigDigFltrTimebaseRate) DAQmxResetDigEdgeArmStartTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetDigEdgeArmStartTrigDigFltrTimebaseRate(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Thrmstr_R1
 ***/
%rename(GetAIThrmstrR1) DAQmxGetAIThrmstrR1;
int32 __CFUNC DAQmxGetAIThrmstrR1(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIThrmstrR1) DAQmxSetAIThrmstrR1;
int32 __CFUNC DAQmxSetAIThrmstrR1(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIThrmstrR1) DAQmxResetAIThrmstrR1;
int32 __CFUNC DAQmxResetAIThrmstrR1(TaskHandle taskHandle, const char channel[]);
/*** Channel Set/Get functions for DAQmx_AI_Max
 ***/
%rename(GetAIMax) DAQmxGetAIMax;
int32 __CFUNC DAQmxGetAIMax(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIMax) DAQmxSetAIMax;
int32 __CFUNC DAQmxSetAIMax(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIMax) DAQmxResetAIMax;
int32 __CFUNC DAQmxResetAIMax(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CtrTimebase_DigSync_Enable
 ***/
%rename(GetCICtrTimebaseDigSyncEnable) DAQmxGetCICtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxGetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICtrTimebaseDigSyncEnable) DAQmxSetCICtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxSetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICtrTimebaseDigSyncEnable) DAQmxResetCICtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxResetCICtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_OverWrite Uses value set
 *** OverwriteMode1
 ***/
%rename(GetReadOverWrite) DAQmxGetReadOverWrite;
int32 __CFUNC DAQmxGetReadOverWrite(TaskHandle taskHandle, int32 *data);
%rename(SetReadOverWrite) DAQmxSetReadOverWrite;
int32 __CFUNC DAQmxSetReadOverWrite(TaskHandle taskHandle, int32 data);
%rename(ResetReadOverWrite) DAQmxResetReadOverWrite;
int32 __CFUNC DAQmxResetReadOverWrite(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgLvl_PauseTrig_When Uses value set
 *** ActiveLevel
 ***/
%rename(GetAnlgLvlPauseTrigWhen) DAQmxGetAnlgLvlPauseTrigWhen;
int32 __CFUNC DAQmxGetAnlgLvlPauseTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgLvlPauseTrigWhen) DAQmxSetAnlgLvlPauseTrigWhen;
int32 __CFUNC DAQmxSetAnlgLvlPauseTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgLvlPauseTrigWhen) DAQmxResetAnlgLvlPauseTrigWhen;
int32 __CFUNC DAQmxResetAnlgLvlPauseTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_BusType Uses value set BusType
 ***/
%rename(GetDevBusType) DAQmxGetDevBusType;
int32 __CFUNC DAQmxGetDevBusType(const char device[], int32 *data);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_First_DigFltr_TimebaseRate
 ***/
%rename(GetCITwoEdgeSepFirstDigFltrTimebaseRate) DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCITwoEdgeSepFirstDigFltrTimebaseRate) DAQmxSetCITwoEdgeSepFirstDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCITwoEdgeSepFirstDigFltrTimebaseRate) DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgEdge_StartTrig_Coupling Uses
 *** value set Coupling2
 ***/
%rename(GetAnlgEdgeStartTrigCoupling) DAQmxGetAnlgEdgeStartTrigCoupling;
int32 __CFUNC DAQmxGetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgEdgeStartTrigCoupling) DAQmxSetAnlgEdgeStartTrigCoupling;
int32 __CFUNC DAQmxSetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgEdgeStartTrigCoupling) DAQmxResetAnlgEdgeStartTrigCoupling;
int32 __CFUNC DAQmxResetAnlgEdgeStartTrigCoupling(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampClk_DigFltr_MinPulseWidth
 ***/
%rename(GetSampClkDigFltrMinPulseWidth) DAQmxGetSampClkDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetSampClkDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetSampClkDigFltrMinPulseWidth) DAQmxSetSampClkDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetSampClkDigFltrMinPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetSampClkDigFltrMinPulseWidth) DAQmxResetSampClkDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetSampClkDigFltrMinPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Timestamp_Units Uses value set
 *** TimeUnits
 ***/
%rename(GetCITimestampUnits) DAQmxGetCITimestampUnits;
int32 __CFUNC DAQmxGetCITimestampUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCITimestampUnits) DAQmxSetCITimestampUnits;
int32 __CFUNC DAQmxSetCITimestampUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCITimestampUnits) DAQmxResetCITimestampUnits;
int32 __CFUNC DAQmxResetCITimestampUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_ChangeDetectEvent_OutputTerm
 ***/
%rename(GetExportedChangeDetectEventOutputTerm) DAQmxGetExportedChangeDetectEventOutputTerm;
int32 __CFUNC DAQmxGetExportedChangeDetectEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedChangeDetectEventOutputTerm) DAQmxSetExportedChangeDetectEventOutputTerm;
int32 __CFUNC DAQmxSetExportedChangeDetectEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedChangeDetectEventOutputTerm) DAQmxResetExportedChangeDetectEventOutputTerm;
int32 __CFUNC DAQmxResetExportedChangeDetectEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgLvl_PauseTrig_Coupling Uses value
 *** set Coupling2
 ***/
%rename(GetAnlgLvlPauseTrigCoupling) DAQmxGetAnlgLvlPauseTrigCoupling;
int32 __CFUNC DAQmxGetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgLvlPauseTrigCoupling) DAQmxSetAnlgLvlPauseTrigCoupling;
int32 __CFUNC DAQmxSetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgLvlPauseTrigCoupling) DAQmxResetAnlgLvlPauseTrigCoupling;
int32 __CFUNC DAQmxResetAnlgLvlPauseTrigCoupling(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampClk_DigSync_Enable
 ***/
%rename(GetSampClkDigSyncEnable) DAQmxGetSampClkDigSyncEnable;
int32 __CFUNC DAQmxGetSampClkDigSyncEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetSampClkDigSyncEnable) DAQmxSetSampClkDigSyncEnable;
int32 __CFUNC DAQmxSetSampClkDigSyncEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetSampClkDigSyncEnable) DAQmxResetSampClkDigSyncEnable;
int32 __CFUNC DAQmxResetSampClkDigSyncEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DI_DataXferMech Uses value set
 *** DataTransferMechanism
 ***/
%rename(GetDIDataXferMech) DAQmxGetDIDataXferMech;
int32 __CFUNC DAQmxGetDIDataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDIDataXferMech) DAQmxSetDIDataXferMech;
int32 __CFUNC DAQmxSetDIDataXferMech(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDIDataXferMech) DAQmxResetDIDataXferMech;
int32 __CFUNC DAQmxResetDIDataXferMech(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Lowpass_SwitchCap_ExtClkDiv
 ***/
%rename(GetAILowpassSwitchCapExtClkDiv) DAQmxGetAILowpassSwitchCapExtClkDiv;
int32 __CFUNC DAQmxGetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAILowpassSwitchCapExtClkDiv) DAQmxSetAILowpassSwitchCapExtClkDiv;
int32 __CFUNC DAQmxSetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAILowpassSwitchCapExtClkDiv) DAQmxResetAILowpassSwitchCapExtClkDiv;
int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_PersistedScale_AllowInteractiveDeletion
 ***/
%rename(GetPersistedScaleAllowInteractiveDeletion) DAQmxGetPersistedScaleAllowInteractiveDeletion;
int32 __CFUNC DAQmxGetPersistedScaleAllowInteractiveDeletion(const char scaleName[], bool32 *data);

/*** Set/Get functions for DAQmx_AI_StrainGage_GageFactor
 ***/
%rename(GetAIStrainGageGageFactor) DAQmxGetAIStrainGageGageFactor;
int32 __CFUNC DAQmxGetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIStrainGageGageFactor) DAQmxSetAIStrainGageGageFactor;
int32 __CFUNC DAQmxSetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIStrainGageGageFactor) DAQmxResetAIStrainGageGageFactor;
int32 __CFUNC DAQmxResetAIStrainGageGageFactor(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_NumLines
 ***/
%rename(GetDONumLines) DAQmxGetDONumLines;
int32 __CFUNC DAQmxGetDONumLines(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for DAQmx_Sys_Tasks
 ***/
%rename(GetSysTasks) DAQmxGetSysTasks;
int32 __CFUNC DAQmxGetSysTasks(char *data, uInt32 bufferSize);
/*** Set/Get functions for
 *** DAQmx_PhysicalChan_AO_ManualControl_ShortDetected
 ***/
%rename(GetPhysicalChanAOManualControlShortDetected) DAQmxGetPhysicalChanAOManualControlShortDetected;
int32 __CFUNC DAQmxGetPhysicalChanAOManualControlShortDetected(const char physicalChannel[], bool32 *data);
/*** Set/Get functions for DAQmx_RealTime_WriteRecoveryMode Uses value
 *** set WaitMode4
 ***/
%rename(GetRealTimeWriteRecoveryMode) DAQmxGetRealTimeWriteRecoveryMode;
int32 __CFUNC DAQmxGetRealTimeWriteRecoveryMode(TaskHandle taskHandle, int32 *data);
%rename(SetRealTimeWriteRecoveryMode) DAQmxSetRealTimeWriteRecoveryMode;
int32 __CFUNC DAQmxSetRealTimeWriteRecoveryMode(TaskHandle taskHandle, int32 data);
%rename(ResetRealTimeWriteRecoveryMode) DAQmxResetRealTimeWriteRecoveryMode;
int32 __CFUNC DAQmxResetRealTimeWriteRecoveryMode(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_AI_DataXferReqCond Uses value set
 *** InputDataTransferCondition
 ***/
%rename(GetAIDataXferReqCond) DAQmxGetAIDataXferReqCond;
int32 __CFUNC DAQmxGetAIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIDataXferReqCond) DAQmxSetAIDataXferReqCond;
int32 __CFUNC DAQmxSetAIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIDataXferReqCond) DAQmxResetAIDataXferReqCond;
int32 __CFUNC DAQmxResetAIDataXferReqCond(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CtrTimebase_DigFltr_TimebaseSrc
 ***/
%rename(GetCICtrTimebaseDigFltrTimebaseSrc) DAQmxGetCICtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICtrTimebaseDigFltrTimebaseSrc) DAQmxSetCICtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCICtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICtrTimebaseDigFltrTimebaseSrc) DAQmxResetCICtrTimebaseDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Min
 ***/
%rename(GetAIMin) DAQmxGetAIMin;
int32 __CFUNC DAQmxGetAIMin(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIMin) DAQmxSetAIMin;
int32 __CFUNC DAQmxSetAIMin(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIMin) DAQmxResetAIMin;
int32 __CFUNC DAQmxResetAIMin(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgEdge_RefTrig_Lvl
 ***/
%rename(GetAnlgEdgeRefTrigLvl) DAQmxGetAnlgEdgeRefTrigLvl;
int32 __CFUNC DAQmxGetAnlgEdgeRefTrigLvl(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgEdgeRefTrigLvl) DAQmxSetAnlgEdgeRefTrigLvl;
int32 __CFUNC DAQmxSetAnlgEdgeRefTrigLvl(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgEdgeRefTrigLvl) DAQmxResetAnlgEdgeRefTrigLvl;
int32 __CFUNC DAQmxResetAnlgEdgeRefTrigLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_TEDS_Units
 ***/
%rename(GetAITEDSUnits) DAQmxGetAITEDSUnits;
int32 __CFUNC DAQmxGetAITEDSUnits(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_SwitchChan_MaxACCarryPwr
 ***/
%rename(GetSwitchChanMaxACCarryPwr) DAQmxGetSwitchChanMaxACCarryPwr;
int32 __CFUNC DAQmxGetSwitchChanMaxACCarryPwr(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_ChanCal_ApplyCalIfExp
 ***/
%rename(GetAIChanCalApplyCalIfExp) DAQmxGetAIChanCalApplyCalIfExp;
int32 __CFUNC DAQmxGetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIChanCalApplyCalIfExp) DAQmxSetAIChanCalApplyCalIfExp;
int32 __CFUNC DAQmxSetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIChanCalApplyCalIfExp) DAQmxResetAIChanCalApplyCalIfExp;
int32 __CFUNC DAQmxResetAIChanCalApplyCalIfExp(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_StartTrig_Coupling Uses value
 *** set Coupling2
 ***/
%rename(GetAnlgWinStartTrigCoupling) DAQmxGetAnlgWinStartTrigCoupling;
int32 __CFUNC DAQmxGetAnlgWinStartTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinStartTrigCoupling) DAQmxSetAnlgWinStartTrigCoupling;
int32 __CFUNC DAQmxSetAnlgWinStartTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinStartTrigCoupling) DAQmxResetAnlgWinStartTrigCoupling;
int32 __CFUNC DAQmxResetAnlgWinStartTrigCoupling(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_SampClk_DelayOffset
 ***/
%rename(GetExportedSampClkDelayOffset) DAQmxGetExportedSampClkDelayOffset;
int32 __CFUNC DAQmxGetExportedSampClkDelayOffset(TaskHandle taskHandle, float64 *data);
%rename(SetExportedSampClkDelayOffset) DAQmxSetExportedSampClkDelayOffset;
int32 __CFUNC DAQmxSetExportedSampClkDelayOffset(TaskHandle taskHandle, float64 data);
%rename(ResetExportedSampClkDelayOffset) DAQmxResetExportedSampClkDelayOffset;
int32 __CFUNC DAQmxResetExportedSampClkDelayOffset(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigPattern_PauseTrig_When Uses value
 *** set DigitalPatternCondition1
 ***/
%rename(GetDigPatternPauseTrigWhen) DAQmxGetDigPatternPauseTrigWhen;
int32 __CFUNC DAQmxGetDigPatternPauseTrigWhen(TaskHandle taskHandle, int32 *data);
%rename(SetDigPatternPauseTrigWhen) DAQmxSetDigPatternPauseTrigWhen;
int32 __CFUNC DAQmxSetDigPatternPauseTrigWhen(TaskHandle taskHandle, int32 data);
%rename(ResetDigPatternPauseTrigWhen) DAQmxResetDigPatternPauseTrigWhen;
int32 __CFUNC DAQmxResetDigPatternPauseTrigWhen(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Scale_Poly_ReverseCoeff
 ***/
%rename(GetScalePolyReverseCoeff) DAQmxGetScalePolyReverseCoeff;
int32 __CFUNC DAQmxGetScalePolyReverseCoeff(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetScalePolyReverseCoeff) DAQmxSetScalePolyReverseCoeff;
int32 __CFUNC DAQmxSetScalePolyReverseCoeff(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_DO_GenerateOn Uses value set
 *** SampleClockActiveOrInactiveEdgeSelection
 ***/
%rename(GetDOGenerateOn) DAQmxGetDOGenerateOn;
int32 __CFUNC DAQmxGetDOGenerateOn(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOGenerateOn) DAQmxSetDOGenerateOn;
int32 __CFUNC DAQmxSetDOGenerateOn(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOGenerateOn) DAQmxResetDOGenerateOn;
int32 __CFUNC DAQmxResetDOGenerateOn(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_OverloadedChans
 ***/
%rename(GetReadOverloadedChans) DAQmxGetReadOverloadedChans;
int32 __CFUNC DAQmxGetReadOverloadedChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Carrier_SerialNum
 ***/
%rename(GetCarrierSerialNum) DAQmxGetCarrierSerialNum;
int32 __CFUNC DAQmxGetCarrierSerialNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_DigPattern_RefTrig_Pattern
 ***/
%rename(GetDigPatternRefTrigPattern) DAQmxGetDigPatternRefTrigPattern;
int32 __CFUNC DAQmxGetDigPatternRefTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternRefTrigPattern) DAQmxSetDigPatternRefTrigPattern;
int32 __CFUNC DAQmxSetDigPatternRefTrigPattern(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternRefTrigPattern) DAQmxResetDigPatternRefTrigPattern;
int32 __CFUNC DAQmxResetDigPatternRefTrigPattern(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_Overcurrent_Limit
 ***/
%rename(GetDOOvercurrentLimit) DAQmxGetDOOvercurrentLimit;
int32 __CFUNC DAQmxGetDOOvercurrentLimit(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetDOOvercurrentLimit) DAQmxSetDOOvercurrentLimit;
int32 __CFUNC DAQmxSetDOOvercurrentLimit(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetDOOvercurrentLimit) DAQmxResetDOOvercurrentLimit;
int32 __CFUNC DAQmxResetDOOvercurrentLimit(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_RealTime_WaitForNextSampClkWaitMode
 *** Uses value set WaitMode3
 ***/
%rename(GetRealTimeWaitForNextSampClkWaitMode) DAQmxGetRealTimeWaitForNextSampClkWaitMode;
int32 __CFUNC DAQmxGetRealTimeWaitForNextSampClkWaitMode(TaskHandle taskHandle, int32 *data);
%rename(SetRealTimeWaitForNextSampClkWaitMode) DAQmxSetRealTimeWaitForNextSampClkWaitMode;
int32 __CFUNC DAQmxSetRealTimeWaitForNextSampClkWaitMode(TaskHandle taskHandle, int32 data);
%rename(ResetRealTimeWaitForNextSampClkWaitMode) DAQmxResetRealTimeWaitForNextSampClkWaitMode;
int32 __CFUNC DAQmxResetRealTimeWaitForNextSampClkWaitMode(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Thrmcpl_ScaleType Uses value set
 *** ScaleType2
 ***/
%rename(GetAIThrmcplScaleType) DAQmxGetAIThrmcplScaleType;
int32 __CFUNC DAQmxGetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIThrmcplScaleType) DAQmxSetAIThrmcplScaleType;
int32 __CFUNC DAQmxSetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIThrmcplScaleType) DAQmxResetAIThrmcplScaleType;
int32 __CFUNC DAQmxResetAIThrmcplScaleType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Buf_Output_OnbrdBufSize
 ***/
%rename(GetBufOutputOnbrdBufSize) DAQmxGetBufOutputOnbrdBufSize;
int32 __CFUNC DAQmxGetBufOutputOnbrdBufSize(TaskHandle taskHandle, uInt32 *data);
%rename(SetBufOutputOnbrdBufSize) DAQmxSetBufOutputOnbrdBufSize;
int32 __CFUNC DAQmxSetBufOutputOnbrdBufSize(TaskHandle taskHandle, uInt32 data);
%rename(ResetBufOutputOnbrdBufSize) DAQmxResetBufOutputOnbrdBufSize;
int32 __CFUNC DAQmxResetBufOutputOnbrdBufSize(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_CI_PulseWidth_Term
 ***/
%rename(GetCIPulseWidthTerm) DAQmxGetCIPulseWidthTerm;
int32 __CFUNC DAQmxGetCIPulseWidthTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIPulseWidthTerm) DAQmxSetCIPulseWidthTerm;
int32 __CFUNC DAQmxSetCIPulseWidthTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIPulseWidthTerm) DAQmxResetCIPulseWidthTerm;
int32 __CFUNC DAQmxResetCIPulseWidthTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_MemMapEnable
 ***/
%rename(GetAOMemMapEnable) DAQmxGetAOMemMapEnable;
int32 __CFUNC DAQmxGetAOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAOMemMapEnable) DAQmxSetAOMemMapEnable;
int32 __CFUNC DAQmxSetAOMemMapEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAOMemMapEnable) DAQmxResetAOMemMapEnable;
int32 __CFUNC DAQmxResetAOMemMapEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Strain_Units Uses value set
 *** StrainUnits1
 ***/
%rename(GetAIStrainUnits) DAQmxGetAIStrainUnits;
int32 __CFUNC DAQmxGetAIStrainUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIStrainUnits) DAQmxSetAIStrainUnits;
int32 __CFUNC DAQmxSetAIStrainUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIStrainUnits) DAQmxResetAIStrainUnits;
int32 __CFUNC DAQmxResetAIStrainUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Coupling Uses value set Coupling1
 ***/
%rename(GetAICoupling) DAQmxGetAICoupling;
int32 __CFUNC DAQmxGetAICoupling(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAICoupling) DAQmxSetAICoupling;
int32 __CFUNC DAQmxSetAICoupling(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAICoupling) DAQmxResetAICoupling;
int32 __CFUNC DAQmxResetAICoupling(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_CtrOutEvent_OutputBehavior
 *** Uses value set ExportActions2
 ***/
%rename(GetExportedCtrOutEventOutputBehavior) DAQmxGetExportedCtrOutEventOutputBehavior;
int32 __CFUNC DAQmxGetExportedCtrOutEventOutputBehavior(TaskHandle taskHandle, int32 *data);
%rename(SetExportedCtrOutEventOutputBehavior) DAQmxSetExportedCtrOutEventOutputBehavior;
int32 __CFUNC DAQmxSetExportedCtrOutEventOutputBehavior(TaskHandle taskHandle, int32 data);
%rename(ResetExportedCtrOutEventOutputBehavior) DAQmxResetExportedCtrOutEventOutputBehavior;
int32 __CFUNC DAQmxResetExportedCtrOutEventOutputBehavior(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_Pulse_DutyCyc
 ***/
%rename(GetCOPulseDutyCyc) DAQmxGetCOPulseDutyCyc;
int32 __CFUNC DAQmxGetCOPulseDutyCyc(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseDutyCyc) DAQmxSetCOPulseDutyCyc;
int32 __CFUNC DAQmxSetCOPulseDutyCyc(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseDutyCyc) DAQmxResetCOPulseDutyCyc;
int32 __CFUNC DAQmxResetCOPulseDutyCyc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_DI_Lines
 ***/
%rename(GetDevDILines) DAQmxGetDevDILines;
int32 __CFUNC DAQmxGetDevDILines(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CI_Encoder_BInput_DigFltr_Enable
 ***/
%rename(GetCIEncoderBInputDigFltrEnable) DAQmxGetCIEncoderBInputDigFltrEnable;
int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderBInputDigFltrEnable) DAQmxSetCIEncoderBInputDigFltrEnable;
int32 __CFUNC DAQmxSetCIEncoderBInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderBInputDigFltrEnable) DAQmxResetCIEncoderBInputDigFltrEnable;
int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_StartTrig_DelayUnits Uses value set
 *** DigitalWidthUnits1
 ***/
%rename(GetStartTrigDelayUnits) DAQmxGetStartTrigDelayUnits;
int32 __CFUNC DAQmxGetStartTrigDelayUnits(TaskHandle taskHandle, int32 *data);
%rename(SetStartTrigDelayUnits) DAQmxSetStartTrigDelayUnits;
int32 __CFUNC DAQmxSetStartTrigDelayUnits(TaskHandle taskHandle, int32 data);
%rename(ResetStartTrigDelayUnits) DAQmxResetStartTrigDelayUnits;
int32 __CFUNC DAQmxResetStartTrigDelayUnits(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_LineStates_DoneState Uses value
 *** set DigitalLineState
 ***/
%rename(GetDOLineStatesDoneState) DAQmxGetDOLineStatesDoneState;
int32 __CFUNC DAQmxGetDOLineStatesDoneState(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOLineStatesDoneState) DAQmxSetDOLineStatesDoneState;
int32 __CFUNC DAQmxSetDOLineStatesDoneState(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOLineStatesDoneState) DAQmxResetDOLineStatesDoneState;
int32 __CFUNC DAQmxResetDOLineStatesDoneState(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_DigSync_Enable
 ***/
%rename(GetDigLvlPauseTrigDigSyncEnable) DAQmxGetDigLvlPauseTrigDigSyncEnable;
int32 __CFUNC DAQmxGetDigLvlPauseTrigDigSyncEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigLvlPauseTrigDigSyncEnable) DAQmxSetDigLvlPauseTrigDigSyncEnable;
int32 __CFUNC DAQmxSetDigLvlPauseTrigDigSyncEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigLvlPauseTrigDigSyncEnable) DAQmxResetDigLvlPauseTrigDigSyncEnable;
int32 __CFUNC DAQmxResetDigLvlPauseTrigDigSyncEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigPattern_PauseTrig_Pattern
 ***/
%rename(GetDigPatternPauseTrigPattern) DAQmxGetDigPatternPauseTrigPattern;
int32 __CFUNC DAQmxGetDigPatternPauseTrigPattern(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternPauseTrigPattern) DAQmxSetDigPatternPauseTrigPattern;
int32 __CFUNC DAQmxSetDigPatternPauseTrigPattern(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternPauseTrigPattern) DAQmxResetDigPatternPauseTrigPattern;
int32 __CFUNC DAQmxResetDigPatternPauseTrigPattern(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_Offset
 ***/
%rename(GetWriteOffset) DAQmxGetWriteOffset;
int32 __CFUNC DAQmxGetWriteOffset(TaskHandle taskHandle, int32 *data);
%rename(SetWriteOffset) DAQmxSetWriteOffset;
int32 __CFUNC DAQmxSetWriteOffset(TaskHandle taskHandle, int32 data);
%rename(ResetWriteOffset) DAQmxResetWriteOffset;
int32 __CFUNC DAQmxResetWriteOffset(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgWin_StartTrig_Top
 ***/
%rename(GetAnlgWinStartTrigTop) DAQmxGetAnlgWinStartTrigTop;
int32 __CFUNC DAQmxGetAnlgWinStartTrigTop(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinStartTrigTop) DAQmxSetAnlgWinStartTrigTop;
int32 __CFUNC DAQmxSetAnlgWinStartTrigTop(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinStartTrigTop) DAQmxResetAnlgWinStartTrigTop;
int32 __CFUNC DAQmxResetAnlgWinStartTrigTop(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_PulseWidth_DigFltr_Enable
 ***/
%rename(GetCIPulseWidthDigFltrEnable) DAQmxGetCIPulseWidthDigFltrEnable;
int32 __CFUNC DAQmxGetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIPulseWidthDigFltrEnable) DAQmxSetCIPulseWidthDigFltrEnable;
int32 __CFUNC DAQmxSetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIPulseWidthDigFltrEnable) DAQmxResetCIPulseWidthDigFltrEnable;
int32 __CFUNC DAQmxResetCIPulseWidthDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_AIConvClk_Pulse_Polarity
 *** Uses value set Polarity2
 ***/
%rename(GetExportedAIConvClkPulsePolarity) DAQmxGetExportedAIConvClkPulsePolarity;
int32 __CFUNC DAQmxGetExportedAIConvClkPulsePolarity(TaskHandle taskHandle, int32 *data);
/*** Set/Get functions for DAQmx_SwitchDev_NumRelays
 ***/
%rename(GetSwitchDevNumRelays) DAQmxGetSwitchDevNumRelays;
int32 __CFUNC DAQmxGetSwitchDevNumRelays(const char deviceName[], uInt32 *data);
/*** Set/Get functions for DAQmx_DigEdge_WatchdogExpirTrig_Src
 ***/
%rename(GetDigEdgeWatchdogExpirTrigSrc) DAQmxGetDigEdgeWatchdogExpirTrigSrc;
int32 __CFUNC DAQmxGetDigEdgeWatchdogExpirTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeWatchdogExpirTrigSrc) DAQmxSetDigEdgeWatchdogExpirTrigSrc;
int32 __CFUNC DAQmxSetDigEdgeWatchdogExpirTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeWatchdogExpirTrigSrc) DAQmxResetDigEdgeWatchdogExpirTrigSrc;
int32 __CFUNC DAQmxResetDigEdgeWatchdogExpirTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Scale_Map_PreScaledMin
 ***/
%rename(GetScaleMapPreScaledMin) DAQmxGetScaleMapPreScaledMin;
int32 __CFUNC DAQmxGetScaleMapPreScaledMin(const char scaleName[], float64 *data);
%rename(SetScaleMapPreScaledMin) DAQmxSetScaleMapPreScaledMin;
int32 __CFUNC DAQmxSetScaleMapPreScaledMin(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_DO_InvertLines
 ***/
%rename(GetDOInvertLines) DAQmxGetDOInvertLines;
int32 __CFUNC DAQmxGetDOInvertLines(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDOInvertLines) DAQmxSetDOInvertLines;
int32 __CFUNC DAQmxSetDOInvertLines(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDOInvertLines) DAQmxResetDOInvertLines;
int32 __CFUNC DAQmxResetDOInvertLines(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_DigFltr_TimebaseSrc
 ***/
%rename(GetCISemiPeriodDigFltrTimebaseSrc) DAQmxGetCISemiPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCISemiPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCISemiPeriodDigFltrTimebaseSrc) DAQmxSetCISemiPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCISemiPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCISemiPeriodDigFltrTimebaseSrc) DAQmxResetCISemiPeriodDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCISemiPeriodDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Sys_DevNames
 ***/
%rename(GetSysDevNames) DAQmxGetSysDevNames;
int32 __CFUNC DAQmxGetSysDevNames(char *data, uInt32 bufferSize);
/*** Set/Get functions for
 *** DAQmx_Exported_WatchdogExpiredEvent_OutputTerm
 ***/
%rename(GetExportedWatchdogExpiredEventOutputTerm) DAQmxGetExportedWatchdogExpiredEventOutputTerm;
int32 __CFUNC DAQmxGetExportedWatchdogExpiredEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedWatchdogExpiredEventOutputTerm) DAQmxSetExportedWatchdogExpiredEventOutputTerm;
int32 __CFUNC DAQmxSetExportedWatchdogExpiredEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedWatchdogExpiredEventOutputTerm) DAQmxResetExportedWatchdogExpiredEventOutputTerm;
int32 __CFUNC DAQmxResetExportedWatchdogExpiredEventOutputTerm(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_Write_CurrWritePos
 ***/
%rename(GetWriteCurrWritePos) DAQmxGetWriteCurrWritePos;
int32 __CFUNC DAQmxGetWriteCurrWritePos(TaskHandle taskHandle, uInt64 *data);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_DigSync_Enable
 ***/
%rename(GetCISemiPeriodDigSyncEnable) DAQmxGetCISemiPeriodDigSyncEnable;
int32 __CFUNC DAQmxGetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCISemiPeriodDigSyncEnable) DAQmxSetCISemiPeriodDigSyncEnable;
int32 __CFUNC DAQmxSetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCISemiPeriodDigSyncEnable) DAQmxResetCISemiPeriodDigSyncEnable;
int32 __CFUNC DAQmxResetCISemiPeriodDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AI_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevAITrigUsage) DAQmxGetDevAITrigUsage;
int32 __CFUNC DAQmxGetDevAITrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_Dev_AI_VoltageIntExcitDiscreteVals
 ***/
%rename(GetDevAIVoltageIntExcitDiscreteVals) DAQmxGetDevAIVoltageIntExcitDiscreteVals;
int32 __CFUNC DAQmxGetDevAIVoltageIntExcitDiscreteVals(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_Thrmstr_C
 ***/
%rename(GetAIThrmstrC) DAQmxGetAIThrmstrC;
int32 __CFUNC DAQmxGetAIThrmstrC(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIThrmstrC) DAQmxSetAIThrmstrC;
int32 __CFUNC DAQmxSetAIThrmstrC(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIThrmstrC) DAQmxResetAIThrmstrC;
int32 __CFUNC DAQmxResetAIThrmstrC(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Thrmstr_B
 ***/
%rename(GetAIThrmstrB) DAQmxGetAIThrmstrB;
int32 __CFUNC DAQmxGetAIThrmstrB(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIThrmstrB) DAQmxSetAIThrmstrB;
int32 __CFUNC DAQmxSetAIThrmstrB(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIThrmstrB) DAQmxResetAIThrmstrB;
int32 __CFUNC DAQmxResetAIThrmstrB(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Thrmstr_A
 ***/
%rename(GetAIThrmstrA) DAQmxGetAIThrmstrA;
int32 __CFUNC DAQmxGetAIThrmstrA(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIThrmstrA) DAQmxSetAIThrmstrA;
int32 __CFUNC DAQmxSetAIThrmstrA(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIThrmstrA) DAQmxResetAIThrmstrA;
int32 __CFUNC DAQmxResetAIThrmstrA(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_WaitMode Uses value set WaitMode
 ***/
%rename(GetReadWaitMode) DAQmxGetReadWaitMode;
int32 __CFUNC DAQmxGetReadWaitMode(TaskHandle taskHandle, int32 *data);
%rename(SetReadWaitMode) DAQmxSetReadWaitMode;
int32 __CFUNC DAQmxSetReadWaitMode(TaskHandle taskHandle, int32 data);
%rename(ResetReadWaitMode) DAQmxResetReadWaitMode;
int32 __CFUNC DAQmxResetReadWaitMode(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Resistance_Units Uses value set
 *** ResistanceUnits1
 ***/
%rename(GetAIResistanceUnits) DAQmxGetAIResistanceUnits;
int32 __CFUNC DAQmxGetAIResistanceUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIResistanceUnits) DAQmxSetAIResistanceUnits;
int32 __CFUNC DAQmxSetAIResistanceUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIResistanceUnits) DAQmxResetAIResistanceUnits;
int32 __CFUNC DAQmxResetAIResistanceUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_RefTrig_Src
 ***/
%rename(GetAnlgWinRefTrigSrc) DAQmxGetAnlgWinRefTrigSrc;
int32 __CFUNC DAQmxGetAnlgWinRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgWinRefTrigSrc) DAQmxSetAnlgWinRefTrigSrc;
int32 __CFUNC DAQmxSetAnlgWinRefTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgWinRefTrigSrc) DAQmxResetAnlgWinRefTrigSrc;
int32 __CFUNC DAQmxResetAnlgWinRefTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Bridge_Balance_FinePot
 ***/
%rename(GetAIBridgeBalanceFinePot) DAQmxGetAIBridgeBalanceFinePot;
int32 __CFUNC DAQmxGetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIBridgeBalanceFinePot) DAQmxSetAIBridgeBalanceFinePot;
int32 __CFUNC DAQmxSetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIBridgeBalanceFinePot) DAQmxResetAIBridgeBalanceFinePot;
int32 __CFUNC DAQmxResetAIBridgeBalanceFinePot(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_FuncGen_ModulationType Uses value
 *** set ModulationType
 ***/
%rename(GetAOFuncGenModulationType) DAQmxGetAOFuncGenModulationType;
int32 __CFUNC DAQmxGetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOFuncGenModulationType) DAQmxSetAOFuncGenModulationType;
int32 __CFUNC DAQmxSetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOFuncGenModulationType) DAQmxResetAOFuncGenModulationType;
int32 __CFUNC DAQmxResetAOFuncGenModulationType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AI_MaxMultiChanRate
 ***/
%rename(GetDevAIMaxMultiChanRate) DAQmxGetDevAIMaxMultiChanRate;
int32 __CFUNC DAQmxGetDevAIMaxMultiChanRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_Write_DigitalLines_BytesPerChan
 ***/
%rename(GetWriteDigitalLinesBytesPerChan) DAQmxGetWriteDigitalLinesBytesPerChan;
int32 __CFUNC DAQmxGetWriteDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);

/*** Set/Get functions for DAQmx_Dev_AI_MaxSingleChanRate
 ***/
%rename(GetDevAIMaxSingleChanRate) DAQmxGetDevAIMaxSingleChanRate;
int32 __CFUNC DAQmxGetDevAIMaxSingleChanRate(const char device[], float64 *data);
/*** Set/Get functions for DAQmx_AIConv_Rate
 ***/
%rename(GetAIConvRate) DAQmxGetAIConvRate;
int32 __CFUNC DAQmxGetAIConvRate(TaskHandle taskHandle, float64 *data);
%rename(SetAIConvRate) DAQmxSetAIConvRate;
int32 __CFUNC DAQmxSetAIConvRate(TaskHandle taskHandle, float64 data);
%rename(ResetAIConvRate) DAQmxResetAIConvRate;
int32 __CFUNC DAQmxResetAIConvRate(TaskHandle taskHandle);
%rename(GetAIConvRateEx) DAQmxGetAIConvRateEx;
int32 __CFUNC DAQmxGetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[], float64 *data);
%rename(SetAIConvRateEx) DAQmxSetAIConvRateEx;
int32 __CFUNC DAQmxSetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[], float64 data);
%rename(ResetAIConvRateEx) DAQmxResetAIConvRateEx;
int32 __CFUNC DAQmxResetAIConvRateEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_Dev_PCI_BusNum
 ***/
%rename(GetDevPCIBusNum) DAQmxGetDevPCIBusNum;
int32 __CFUNC DAQmxGetDevPCIBusNum(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_SampClk_DigFltr_TimebaseSrc
 ***/
%rename(GetSampClkDigFltrTimebaseSrc) DAQmxGetSampClkDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetSampClkDigFltrTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetSampClkDigFltrTimebaseSrc) DAQmxSetSampClkDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetSampClkDigFltrTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetSampClkDigFltrTimebaseSrc) DAQmxResetSampClkDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetSampClkDigFltrTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_Exported_RdyForXferEvent_DeassertCondCustomThreshold
 ***/
%rename(GetExportedRdyForXferEventDeassertCondCustomThreshold) DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold;
int32 __CFUNC DAQmxGetExportedRdyForXferEventDeassertCondCustomThreshold(TaskHandle taskHandle, uInt32 *data);
%rename(SetExportedRdyForXferEventDeassertCondCustomThreshold) DAQmxSetExportedRdyForXferEventDeassertCondCustomThreshold;
int32 __CFUNC DAQmxSetExportedRdyForXferEventDeassertCondCustomThreshold(TaskHandle taskHandle, uInt32 data);
%rename(ResetExportedRdyForXferEventDeassertCondCustomThreshold) DAQmxResetExportedRdyForXferEventDeassertCondCustomThreshold;
int32 __CFUNC DAQmxResetExportedRdyForXferEventDeassertCondCustomThreshold(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AO_CurrentRngs
 ***/
%rename(GetDevAOCurrentRngs) DAQmxGetDevAOCurrentRngs;
int32 __CFUNC DAQmxGetDevAOCurrentRngs(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_CI_CountEdges_Dir Uses value set
 *** CountDirection1
 ***/
%rename(GetCICountEdgesDir) DAQmxGetCICountEdgesDir;
int32 __CFUNC DAQmxGetCICountEdgesDir(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCICountEdgesDir) DAQmxSetCICountEdgesDir;
int32 __CFUNC DAQmxSetCICountEdgesDir(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCICountEdgesDir) DAQmxResetCICountEdgesDir;
int32 __CFUNC DAQmxResetCICountEdgesDir(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_DigFltr_TimebaseSrc
 ***/
%rename(GetCICountEdgesDigFltrTimebaseSrc) DAQmxGetCICountEdgesDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCICountEdgesDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICountEdgesDigFltrTimebaseSrc) DAQmxSetCICountEdgesDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCICountEdgesDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICountEdgesDigFltrTimebaseSrc) DAQmxResetCICountEdgesDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCICountEdgesDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_Exported_ChangeDetectEvent_Pulse_Polarity Uses value set
 *** Polarity2
 ***/
%rename(GetExportedChangeDetectEventPulsePolarity) DAQmxGetExportedChangeDetectEventPulsePolarity;
int32 __CFUNC DAQmxGetExportedChangeDetectEventPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedChangeDetectEventPulsePolarity) DAQmxSetExportedChangeDetectEventPulsePolarity;
int32 __CFUNC DAQmxSetExportedChangeDetectEventPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedChangeDetectEventPulsePolarity) DAQmxResetExportedChangeDetectEventPulsePolarity;
int32 __CFUNC DAQmxResetExportedChangeDetectEventPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_CI_CountEdges_CountDir_DigFltr_TimebaseRate
 ***/
%rename(GetCICountEdgesCountDirDigFltrTimebaseRate) DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICountEdgesCountDirDigFltrTimebaseRate) DAQmxSetCICountEdgesCountDirDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCICountEdgesCountDirDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICountEdgesCountDirDigFltrTimebaseRate) DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_CountEdges_CountDir_DigFltr_MinPulseWidth
 ***/
%rename(GetCICountEdgesCountDirDigFltrMinPulseWidth) DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCICountEdgesCountDirDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICountEdgesCountDirDigFltrMinPulseWidth) DAQmxSetCICountEdgesCountDirDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCICountEdgesCountDirDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICountEdgesCountDirDigFltrMinPulseWidth) DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCICountEdgesCountDirDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_NumRows
 ***/
%rename(GetSwitchDevNumRows) DAQmxGetSwitchDevNumRows;
int32 __CFUNC DAQmxGetSwitchDevNumRows(const char deviceName[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_CtrTimebaseActiveEdge Uses value
 *** set Edge1
 ***/
%rename(GetCICtrTimebaseActiveEdge) DAQmxGetCICtrTimebaseActiveEdge;
int32 __CFUNC DAQmxGetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCICtrTimebaseActiveEdge) DAQmxSetCICtrTimebaseActiveEdge;
int32 __CFUNC DAQmxSetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCICtrTimebaseActiveEdge) DAQmxResetCICtrTimebaseActiveEdge;
int32 __CFUNC DAQmxResetCICtrTimebaseActiveEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Lowpass_CutoffFreq
 ***/
%rename(GetAILowpassCutoffFreq) DAQmxGetAILowpassCutoffFreq;
int32 __CFUNC DAQmxGetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAILowpassCutoffFreq) DAQmxSetAILowpassCutoffFreq;
int32 __CFUNC DAQmxSetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAILowpassCutoffFreq) DAQmxResetAILowpassCutoffFreq;
int32 __CFUNC DAQmxResetAILowpassCutoffFreq(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_AInput_DigFltr_MinPulseWidth
 ***/
%rename(GetCIEncoderAInputDigFltrMinPulseWidth) DAQmxGetCIEncoderAInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderAInputDigFltrMinPulseWidth) DAQmxSetCIEncoderAInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIEncoderAInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderAInputDigFltrMinPulseWidth) DAQmxResetCIEncoderAInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgLvl_PauseTrig_Hyst
 ***/
%rename(GetAnlgLvlPauseTrigHyst) DAQmxGetAnlgLvlPauseTrigHyst;
int32 __CFUNC DAQmxGetAnlgLvlPauseTrigHyst(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgLvlPauseTrigHyst) DAQmxSetAnlgLvlPauseTrigHyst;
int32 __CFUNC DAQmxSetAnlgLvlPauseTrigHyst(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgLvlPauseTrigHyst) DAQmxResetAnlgLvlPauseTrigHyst;
int32 __CFUNC DAQmxResetAnlgLvlPauseTrigHyst(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CtrTimebaseMasterTimebaseDiv
 ***/
%rename(GetCICtrTimebaseMasterTimebaseDiv) DAQmxGetCICtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxGetCICtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCICtrTimebaseMasterTimebaseDiv) DAQmxSetCICtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxSetCICtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCICtrTimebaseMasterTimebaseDiv) DAQmxResetCICtrTimebaseMasterTimebaseDiv;
int32 __CFUNC DAQmxResetCICtrTimebaseMasterTimebaseDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Rng_Low
 ***/
%rename(GetAIRngLow) DAQmxGetAIRngLow;
int32 __CFUNC DAQmxGetAIRngLow(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIRngLow) DAQmxSetAIRngLow;
int32 __CFUNC DAQmxSetAIRngLow(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIRngLow) DAQmxResetAIRngLow;
int32 __CFUNC DAQmxResetAIRngLow(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchChan_MaxDCCarryPwr
 ***/
%rename(GetSwitchChanMaxDCCarryPwr) DAQmxGetSwitchChanMaxDCCarryPwr;
int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryPwr(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_CI_Min
 ***/
%rename(GetCIMin) DAQmxGetCIMin;
int32 __CFUNC DAQmxGetCIMin(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIMin) DAQmxSetCIMin;
int32 __CFUNC DAQmxSetCIMin(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIMin) DAQmxResetCIMin;
int32 __CFUNC DAQmxResetCIMin(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ForceReadFromChan
 ***/
%rename(GetAIForceReadFromChan) DAQmxGetAIForceReadFromChan;
int32 __CFUNC DAQmxGetAIForceReadFromChan(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAIForceReadFromChan) DAQmxSetAIForceReadFromChan;
int32 __CFUNC DAQmxSetAIForceReadFromChan(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAIForceReadFromChan) DAQmxResetAIForceReadFromChan;
int32 __CFUNC DAQmxResetAIForceReadFromChan(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_RawSampJustification Uses value
 *** set DataJustification1
 ***/
%rename(GetAIRawSampJustification) DAQmxGetAIRawSampJustification;
int32 __CFUNC DAQmxGetAIRawSampJustification(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_CI_Encoder_ZInput_DigFltr_Enable
 ***/
%rename(GetCIEncoderZInputDigFltrEnable) DAQmxGetCIEncoderZInputDigFltrEnable;
int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderZInputDigFltrEnable) DAQmxSetCIEncoderZInputDigFltrEnable;
int32 __CFUNC DAQmxSetCIEncoderZInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderZInputDigFltrEnable) DAQmxResetCIEncoderZInputDigFltrEnable;
int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CO_MaxSize
 ***/
%rename(GetDevCOMaxSize) DAQmxGetDevCOMaxSize;
int32 __CFUNC DAQmxGetDevCOMaxSize(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_CI_TCReached
 ***/
%rename(GetCITCReached) DAQmxGetCITCReached;
int32 __CFUNC DAQmxGetCITCReached(TaskHandle taskHandle, const char channel[], bool32 *data);
/*** Set/Get functions for DAQmx_DI_DataXferReqCond Uses value set
 *** InputDataTransferCondition
 ***/
%rename(GetDIDataXferReqCond) DAQmxGetDIDataXferReqCond;
int32 __CFUNC DAQmxGetDIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDIDataXferReqCond) DAQmxSetDIDataXferReqCond;
int32 __CFUNC DAQmxSetDIDataXferReqCond(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDIDataXferReqCond) DAQmxResetDIDataXferReqCond;
int32 __CFUNC DAQmxResetDIDataXferReqCond(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SwitchDev_AutoConnAnlgBus
 ***/
%rename(GetSwitchDevAutoConnAnlgBus) DAQmxGetSwitchDevAutoConnAnlgBus;
int32 __CFUNC DAQmxGetSwitchDevAutoConnAnlgBus(const char deviceName[], bool32 *data);
%rename(SetSwitchDevAutoConnAnlgBus) DAQmxSetSwitchDevAutoConnAnlgBus;
int32 __CFUNC DAQmxSetSwitchDevAutoConnAnlgBus(const char deviceName[], bool32 data);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_ModelNum
 ***/
%rename(GetPhysicalChanTEDSModelNum) DAQmxGetPhysicalChanTEDSModelNum;
int32 __CFUNC DAQmxGetPhysicalChanTEDSModelNum(const char physicalChannel[], uInt32 *data);
/*** Set/Get functions for DAQmx_Task_Complete
 ***/
%rename(GetTaskComplete) DAQmxGetTaskComplete;
int32 __CFUNC DAQmxGetTaskComplete(TaskHandle taskHandle, bool32 *data);

/*** Set/Get functions for DAQmx_PhysicalChan_DI_ChangeDetectSupported
 ***/
%rename(GetPhysicalChanDIChangeDetectSupported) DAQmxGetPhysicalChanDIChangeDetectSupported;
int32 __CFUNC DAQmxGetPhysicalChanDIChangeDetectSupported(const char physicalChannel[], bool32 *data);
/*** Set/Get functions for DAQmx_AO_DataXferMech Uses value set
 *** DataTransferMechanism
 ***/
%rename(GetAODataXferMech) DAQmxGetAODataXferMech;
int32 __CFUNC DAQmxGetAODataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAODataXferMech) DAQmxSetAODataXferMech;
int32 __CFUNC DAQmxSetAODataXferMech(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAODataXferMech) DAQmxResetAODataXferMech;
int32 __CFUNC DAQmxResetAODataXferMech(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Lowpass_Enable
 ***/
%rename(GetAILowpassEnable) DAQmxGetAILowpassEnable;
int32 __CFUNC DAQmxGetAILowpassEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAILowpassEnable) DAQmxSetAILowpassEnable;
int32 __CFUNC DAQmxSetAILowpassEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAILowpassEnable) DAQmxResetAILowpassEnable;
int32 __CFUNC DAQmxResetAILowpassEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_PauseTrig_Lvl_ActiveLvl Uses
 *** value set Polarity2
 ***/
%rename(GetExportedPauseTrigLvlActiveLvl) DAQmxGetExportedPauseTrigLvlActiveLvl;
int32 __CFUNC DAQmxGetExportedPauseTrigLvlActiveLvl(TaskHandle taskHandle, int32 *data);
%rename(SetExportedPauseTrigLvlActiveLvl) DAQmxSetExportedPauseTrigLvlActiveLvl;
int32 __CFUNC DAQmxSetExportedPauseTrigLvlActiveLvl(TaskHandle taskHandle, int32 data);
%rename(ResetExportedPauseTrigLvlActiveLvl) DAQmxResetExportedPauseTrigLvlActiveLvl;
int32 __CFUNC DAQmxResetExportedPauseTrigLvlActiveLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_PowerSupplyFaultChans
 ***/
%rename(GetWritePowerSupplyFaultChans) DAQmxGetWritePowerSupplyFaultChans;
int32 __CFUNC DAQmxGetWritePowerSupplyFaultChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CI_AngEncoder_InitialAngle
 ***/
%rename(GetCIAngEncoderInitialAngle) DAQmxGetCIAngEncoderInitialAngle;
int32 __CFUNC DAQmxGetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIAngEncoderInitialAngle) DAQmxSetCIAngEncoderInitialAngle;
int32 __CFUNC DAQmxSetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIAngEncoderInitialAngle) DAQmxResetCIAngEncoderInitialAngle;
int32 __CFUNC DAQmxResetCIAngEncoderInitialAngle(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_ZInput_DigSync_Enable
 ***/
%rename(GetCIEncoderZInputDigSyncEnable) DAQmxGetCIEncoderZInputDigSyncEnable;
int32 __CFUNC DAQmxGetCIEncoderZInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderZInputDigSyncEnable) DAQmxSetCIEncoderZInputDigSyncEnable;
int32 __CFUNC DAQmxSetCIEncoderZInputDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderZInputDigSyncEnable) DAQmxResetCIEncoderZInputDigSyncEnable;
int32 __CFUNC DAQmxResetCIEncoderZInputDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_StartingEdge Uses value
 *** set Edge1
 ***/
%rename(GetCISemiPeriodStartingEdge) DAQmxGetCISemiPeriodStartingEdge;
int32 __CFUNC DAQmxGetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCISemiPeriodStartingEdge) DAQmxSetCISemiPeriodStartingEdge;
int32 __CFUNC DAQmxSetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCISemiPeriodStartingEdge) DAQmxResetCISemiPeriodStartingEdge;
int32 __CFUNC DAQmxResetCISemiPeriodStartingEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Period_Term
 ***/
%rename(GetCIPeriodTerm) DAQmxGetCIPeriodTerm;
int32 __CFUNC DAQmxGetCIPeriodTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIPeriodTerm) DAQmxSetCIPeriodTerm;
int32 __CFUNC DAQmxSetCIPeriodTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIPeriodTerm) DAQmxResetCIPeriodTerm;
int32 __CFUNC DAQmxResetCIPeriodTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_StartTrig_DigFltr_Enable
 ***/
%rename(GetDigEdgeStartTrigDigFltrEnable) DAQmxGetDigEdgeStartTrigDigFltrEnable;
int32 __CFUNC DAQmxGetDigEdgeStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetDigEdgeStartTrigDigFltrEnable) DAQmxSetDigEdgeStartTrigDigFltrEnable;
int32 __CFUNC DAQmxSetDigEdgeStartTrigDigFltrEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetDigEdgeStartTrigDigFltrEnable) DAQmxResetDigEdgeStartTrigDigFltrEnable;
int32 __CFUNC DAQmxResetDigEdgeStartTrigDigFltrEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigEdge_AdvTrig_Edge Uses value set
 *** Edge1
 ***/
%rename(GetDigEdgeAdvTrigEdge) DAQmxGetDigEdgeAdvTrigEdge;
int32 __CFUNC DAQmxGetDigEdgeAdvTrigEdge(TaskHandle taskHandle, int32 *data);
%rename(SetDigEdgeAdvTrigEdge) DAQmxSetDigEdgeAdvTrigEdge;
int32 __CFUNC DAQmxSetDigEdgeAdvTrigEdge(TaskHandle taskHandle, int32 data);
%rename(ResetDigEdgeAdvTrigEdge) DAQmxResetDigEdgeAdvTrigEdge;
int32 __CFUNC DAQmxResetDigEdgeAdvTrigEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_DAC_Offset_Src Uses value set
 *** SourceSelection
 ***/
%rename(GetAODACOffsetSrc) DAQmxGetAODACOffsetSrc;
int32 __CFUNC DAQmxGetAODACOffsetSrc(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAODACOffsetSrc) DAQmxSetAODACOffsetSrc;
int32 __CFUNC DAQmxSetAODACOffsetSrc(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAODACOffsetSrc) DAQmxResetAODACOffsetSrc;
int32 __CFUNC DAQmxResetAODACOffsetSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AI_MinRate
 ***/
%rename(GetDevAIMinRate) DAQmxGetDevAIMinRate;
int32 __CFUNC DAQmxGetDevAIMinRate(const char device[], float64 *data);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_BInput_DigFltr_MinPulseWidth
 ***/
%rename(GetCIEncoderBInputDigFltrMinPulseWidth) DAQmxGetCIEncoderBInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIEncoderBInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderBInputDigFltrMinPulseWidth) DAQmxSetCIEncoderBInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIEncoderBInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderBInputDigFltrMinPulseWidth) DAQmxResetCIEncoderBInputDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIEncoderBInputDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_HighTime
 ***/
%rename(GetCOPulseHighTime) DAQmxGetCOPulseHighTime;
int32 __CFUNC DAQmxGetCOPulseHighTime(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseHighTime) DAQmxSetCOPulseHighTime;
int32 __CFUNC DAQmxSetCOPulseHighTime(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseHighTime) DAQmxResetCOPulseHighTime;
int32 __CFUNC DAQmxResetCOPulseHighTime(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_RefTrig_Pulse_Polarity Uses
 *** value set Polarity2
 ***/
%rename(GetExportedRefTrigPulsePolarity) DAQmxGetExportedRefTrigPulsePolarity;
int32 __CFUNC DAQmxGetExportedRefTrigPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedRefTrigPulsePolarity) DAQmxSetExportedRefTrigPulsePolarity;
int32 __CFUNC DAQmxSetExportedRefTrigPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedRefTrigPulsePolarity) DAQmxResetExportedRefTrigPulsePolarity;
int32 __CFUNC DAQmxResetExportedRefTrigPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_Second_DigSync_Enable
 ***/
%rename(GetCITwoEdgeSepSecondDigSyncEnable) DAQmxGetCITwoEdgeSepSecondDigSyncEnable;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCITwoEdgeSepSecondDigSyncEnable) DAQmxSetCITwoEdgeSepSecondDigSyncEnable;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCITwoEdgeSepSecondDigSyncEnable) DAQmxResetCITwoEdgeSepSecondDigSyncEnable;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_PulseWidth_DigSync_Enable
 ***/
%rename(GetCIPulseWidthDigSyncEnable) DAQmxGetCIPulseWidthDigSyncEnable;
int32 __CFUNC DAQmxGetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIPulseWidthDigSyncEnable) DAQmxSetCIPulseWidthDigSyncEnable;
int32 __CFUNC DAQmxSetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIPulseWidthDigSyncEnable) DAQmxResetCIPulseWidthDigSyncEnable;
int32 __CFUNC DAQmxResetCIPulseWidthDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_LoadImpedance
 ***/
%rename(GetAOLoadImpedance) DAQmxGetAOLoadImpedance;
int32 __CFUNC DAQmxGetAOLoadImpedance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOLoadImpedance) DAQmxSetAOLoadImpedance;
int32 __CFUNC DAQmxSetAOLoadImpedance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOLoadImpedance) DAQmxResetAOLoadImpedance;
int32 __CFUNC DAQmxResetAOLoadImpedance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_MaxRate
 ***/
%rename(GetSampClkMaxRate) DAQmxGetSampClkMaxRate;
int32 __CFUNC DAQmxGetSampClkMaxRate(TaskHandle taskHandle, float64 *data);
/*** Set/Get functions for DAQmx_CI_GPS_SyncSrc
 ***/
%rename(GetCIGPSSyncSrc) DAQmxGetCIGPSSyncSrc;
int32 __CFUNC DAQmxGetCIGPSSyncSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIGPSSyncSrc) DAQmxSetCIGPSSyncSrc;
int32 __CFUNC DAQmxSetCIGPSSyncSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIGPSSyncSrc) DAQmxResetCIGPSSyncSrc;
int32 __CFUNC DAQmxResetCIGPSSyncSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_NumDMAChans
 ***/
%rename(GetDevNumDMAChans) DAQmxGetDevNumDMAChans;
int32 __CFUNC DAQmxGetDevNumDMAChans(const char device[], uInt32 *data);
/*** Set/Get functions for DAQmx_AnlgEdge_StartTrig_Lvl
 ***/
%rename(GetAnlgEdgeStartTrigLvl) DAQmxGetAnlgEdgeStartTrigLvl;
int32 __CFUNC DAQmxGetAnlgEdgeStartTrigLvl(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgEdgeStartTrigLvl) DAQmxSetAnlgEdgeStartTrigLvl;
int32 __CFUNC DAQmxSetAnlgEdgeStartTrigLvl(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgEdgeStartTrigLvl) DAQmxResetAnlgEdgeStartTrigLvl;
int32 __CFUNC DAQmxResetAnlgEdgeStartTrigLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_OpenThrmcplChansExist
 ***/
%rename(GetReadOpenThrmcplChansExist) DAQmxGetReadOpenThrmcplChansExist;
int32 __CFUNC DAQmxGetReadOpenThrmcplChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_CO_CtrTimebaseSrc
 ***/
%rename(GetCOCtrTimebaseSrc) DAQmxGetCOCtrTimebaseSrc;
int32 __CFUNC DAQmxGetCOCtrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCOCtrTimebaseSrc) DAQmxSetCOCtrTimebaseSrc;
int32 __CFUNC DAQmxSetCOCtrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCOCtrTimebaseSrc) DAQmxResetCOCtrTimebaseSrc;
int32 __CFUNC DAQmxResetCOCtrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChan_AO_ManualControlEnable
 ***/
%rename(GetPhysicalChanAOManualControlEnable) DAQmxGetPhysicalChanAOManualControlEnable;
int32 __CFUNC DAQmxGetPhysicalChanAOManualControlEnable(const char physicalChannel[], bool32 *data);
%rename(SetPhysicalChanAOManualControlEnable) DAQmxSetPhysicalChanAOManualControlEnable;
int32 __CFUNC DAQmxSetPhysicalChanAOManualControlEnable(const char physicalChannel[], bool32 data);
%rename(ResetPhysicalChanAOManualControlEnable) DAQmxResetPhysicalChanAOManualControlEnable;
int32 __CFUNC DAQmxResetPhysicalChanAOManualControlEnable(const char physicalChannel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_Term
 ***/
%rename(GetCICountEdgesTerm) DAQmxGetCICountEdgesTerm;
int32 __CFUNC DAQmxGetCICountEdgesTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICountEdgesTerm) DAQmxSetCICountEdgesTerm;
int32 __CFUNC DAQmxSetCICountEdgesTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICountEdgesTerm) DAQmxResetCICountEdgesTerm;
int32 __CFUNC DAQmxResetCICountEdgesTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_Pulse_IdleState Uses value set
 *** Level1
 ***/
%rename(GetCOPulseIdleState) DAQmxGetCOPulseIdleState;
int32 __CFUNC DAQmxGetCOPulseIdleState(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCOPulseIdleState) DAQmxSetCOPulseIdleState;
int32 __CFUNC DAQmxSetCOPulseIdleState(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCOPulseIdleState) DAQmxResetCOPulseIdleState;
int32 __CFUNC DAQmxResetCOPulseIdleState(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_MeasType Uses value set
 *** CIMeasurementType
 ***/
%rename(GetCIMeasType) DAQmxGetCIMeasType;
int32 __CFUNC DAQmxGetCIMeasType(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_AO_UsbXferReqSize
 ***/
%rename(GetAOUsbXferReqSize) DAQmxGetAOUsbXferReqSize;
int32 __CFUNC DAQmxGetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetAOUsbXferReqSize) DAQmxSetAOUsbXferReqSize;
int32 __CFUNC DAQmxSetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetAOUsbXferReqSize) DAQmxResetAOUsbXferReqSize;
int32 __CFUNC DAQmxResetAOUsbXferReqSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CI_SampClkSupported
 ***/
%rename(GetDevCISampClkSupported) DAQmxGetDevCISampClkSupported;
int32 __CFUNC DAQmxGetDevCISampClkSupported(const char device[], bool32 *data);
/*** Set/Get functions for DAQmx_AO_OutputImpedance
 ***/
%rename(GetAOOutputImpedance) DAQmxGetAOOutputImpedance;
int32 __CFUNC DAQmxGetAOOutputImpedance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOOutputImpedance) DAQmxSetAOOutputImpedance;
int32 __CFUNC DAQmxSetAOOutputImpedance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOOutputImpedance) DAQmxResetAOOutputImpedance;
int32 __CFUNC DAQmxResetAOOutputImpedance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_ChanCal_Desc
 ***/
%rename(GetAIChanCalDesc) DAQmxGetAIChanCalDesc;
int32 __CFUNC DAQmxGetAIChanCalDesc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAIChanCalDesc) DAQmxSetAIChanCalDesc;
int32 __CFUNC DAQmxSetAIChanCalDesc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAIChanCalDesc) DAQmxResetAIChanCalDesc;
int32 __CFUNC DAQmxResetAIChanCalDesc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Prescaler
 ***/
%rename(GetCIPrescaler) DAQmxGetCIPrescaler;
int32 __CFUNC DAQmxGetCIPrescaler(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCIPrescaler) DAQmxSetCIPrescaler;
int32 __CFUNC DAQmxSetCIPrescaler(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCIPrescaler) DAQmxResetCIPrescaler;
int32 __CFUNC DAQmxResetCIPrescaler(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_DAC_Ref_ExtSrc
 ***/
%rename(GetAODACRefExtSrc) DAQmxGetAODACRefExtSrc;
int32 __CFUNC DAQmxGetAODACRefExtSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetAODACRefExtSrc) DAQmxSetAODACRefExtSrc;
int32 __CFUNC DAQmxSetAODACRefExtSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetAODACRefExtSrc) DAQmxResetAODACRefExtSrc;
int32 __CFUNC DAQmxResetAODACRefExtSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigPattern_RefTrig_Src
 ***/
%rename(GetDigPatternRefTrigSrc) DAQmxGetDigPatternRefTrigSrc;
int32 __CFUNC DAQmxGetDigPatternRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternRefTrigSrc) DAQmxSetDigPatternRefTrigSrc;
int32 __CFUNC DAQmxSetDigPatternRefTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternRefTrigSrc) DAQmxResetDigPatternRefTrigSrc;
int32 __CFUNC DAQmxResetDigPatternRefTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Cal_DevTemp
 ***/
%rename(GetCalDevTemp) DAQmxGetCalDevTemp;
int32 __CFUNC DAQmxGetCalDevTemp(const char deviceName[], float64 *data);

/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_Src
 ***/
%rename(GetDigLvlPauseTrigSrc) DAQmxGetDigLvlPauseTrigSrc;
int32 __CFUNC DAQmxGetDigLvlPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigLvlPauseTrigSrc) DAQmxSetDigLvlPauseTrigSrc;
int32 __CFUNC DAQmxSetDigLvlPauseTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigLvlPauseTrigSrc) DAQmxResetDigLvlPauseTrigSrc;
int32 __CFUNC DAQmxResetDigLvlPauseTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Buf_Output_BufSize
 ***/
%rename(GetBufOutputBufSize) DAQmxGetBufOutputBufSize;
int32 __CFUNC DAQmxGetBufOutputBufSize(TaskHandle taskHandle, uInt32 *data);
%rename(SetBufOutputBufSize) DAQmxSetBufOutputBufSize;
int32 __CFUNC DAQmxSetBufOutputBufSize(TaskHandle taskHandle, uInt32 data);
%rename(ResetBufOutputBufSize) DAQmxResetBufOutputBufSize;
int32 __CFUNC DAQmxResetBufOutputBufSize(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CtrTimebase_DigFltr_Enable
 ***/
%rename(GetCICtrTimebaseDigFltrEnable) DAQmxGetCICtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICtrTimebaseDigFltrEnable) DAQmxSetCICtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxSetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICtrTimebaseDigFltrEnable) DAQmxResetCICtrTimebaseDigFltrEnable;
int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_LeadWireResistance
 ***/
%rename(GetAILeadWireResistance) DAQmxGetAILeadWireResistance;
int32 __CFUNC DAQmxGetAILeadWireResistance(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAILeadWireResistance) DAQmxSetAILeadWireResistance;
int32 __CFUNC DAQmxSetAILeadWireResistance(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAILeadWireResistance) DAQmxResetAILeadWireResistance;
int32 __CFUNC DAQmxResetAILeadWireResistance(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_Terminals
 ***/
%rename(GetDevTerminals) DAQmxGetDevTerminals;
int32 __CFUNC DAQmxGetDevTerminals(const char device[], char *data, uInt32 bufferSize);

/*** Set/Get functions for DAQmx_Exported_AIHoldCmpltEvent_OutputTerm
 ***/
%rename(GetExportedAIHoldCmpltEventOutputTerm) DAQmxGetExportedAIHoldCmpltEventOutputTerm;
int32 __CFUNC DAQmxGetExportedAIHoldCmpltEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedAIHoldCmpltEventOutputTerm) DAQmxSetExportedAIHoldCmpltEventOutputTerm;
int32 __CFUNC DAQmxSetExportedAIHoldCmpltEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedAIHoldCmpltEventOutputTerm) DAQmxResetExportedAIHoldCmpltEventOutputTerm;
int32 __CFUNC DAQmxResetExportedAIHoldCmpltEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_StrainGage_Cfg Uses value set
 *** StrainGageBridgeType1
 ***/
%rename(GetAIStrainGageCfg) DAQmxGetAIStrainGageCfg;
int32 __CFUNC DAQmxGetAIStrainGageCfg(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIStrainGageCfg) DAQmxSetAIStrainGageCfg;
int32 __CFUNC DAQmxSetAIStrainGageCfg(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIStrainGageCfg) DAQmxResetAIStrainGageCfg;
int32 __CFUNC DAQmxResetAIStrainGageCfg(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_RawDataWidth
 ***/
%rename(GetReadRawDataWidth) DAQmxGetReadRawDataWidth;
int32 __CFUNC DAQmxGetReadRawDataWidth(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_DigEdge_StartTrig_Src
 ***/
%rename(GetDigEdgeStartTrigSrc) DAQmxGetDigEdgeStartTrigSrc;
int32 __CFUNC DAQmxGetDigEdgeStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeStartTrigSrc) DAQmxSetDigEdgeStartTrigSrc;
int32 __CFUNC DAQmxSetDigEdgeStartTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeStartTrigSrc) DAQmxResetDigEdgeStartTrigSrc;
int32 __CFUNC DAQmxResetDigEdgeStartTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CountEdges_DirTerm
 ***/
%rename(GetCICountEdgesDirTerm) DAQmxGetCICountEdgesDirTerm;
int32 __CFUNC DAQmxGetCICountEdgesDirTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICountEdgesDirTerm) DAQmxSetCICountEdgesDirTerm;
int32 __CFUNC DAQmxSetCICountEdgesDirTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICountEdgesDirTerm) DAQmxResetCICountEdgesDirTerm;
int32 __CFUNC DAQmxResetCICountEdgesDirTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Period_MeasTime
 ***/
%rename(GetCIPeriodMeasTime) DAQmxGetCIPeriodMeasTime;
int32 __CFUNC DAQmxGetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIPeriodMeasTime) DAQmxSetCIPeriodMeasTime;
int32 __CFUNC DAQmxSetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIPeriodMeasTime) DAQmxResetCIPeriodMeasTime;
int32 __CFUNC DAQmxResetCIPeriodMeasTime(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_RefTrig_Btm
 ***/
%rename(GetAnlgWinRefTrigBtm) DAQmxGetAnlgWinRefTrigBtm;
int32 __CFUNC DAQmxGetAnlgWinRefTrigBtm(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinRefTrigBtm) DAQmxSetAnlgWinRefTrigBtm;
int32 __CFUNC DAQmxSetAnlgWinRefTrigBtm(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinRefTrigBtm) DAQmxResetAnlgWinRefTrigBtm;
int32 __CFUNC DAQmxResetAnlgWinRefTrigBtm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_OpenCurrentLoopChans
 ***/
%rename(GetWriteOpenCurrentLoopChans) DAQmxGetWriteOpenCurrentLoopChans;
int32 __CFUNC DAQmxGetWriteOpenCurrentLoopChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_Read_SleepTime
 ***/
%rename(GetReadSleepTime) DAQmxGetReadSleepTime;
int32 __CFUNC DAQmxGetReadSleepTime(TaskHandle taskHandle, float64 *data);
%rename(SetReadSleepTime) DAQmxSetReadSleepTime;
int32 __CFUNC DAQmxSetReadSleepTime(TaskHandle taskHandle, float64 data);
%rename(ResetReadSleepTime) DAQmxResetReadSleepTime;
int32 __CFUNC DAQmxResetReadSleepTime(TaskHandle taskHandle);

/*** Set/Get functions for DAQmx_AI_Excit_ActualVal
 ***/
%rename(GetAIExcitActualVal) DAQmxGetAIExcitActualVal;
int32 __CFUNC DAQmxGetAIExcitActualVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIExcitActualVal) DAQmxSetAIExcitActualVal;
int32 __CFUNC DAQmxSetAIExcitActualVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIExcitActualVal) DAQmxResetAIExcitActualVal;
int32 __CFUNC DAQmxResetAIExcitActualVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_AutoIncrCnt
 ***/
%rename(GetCOAutoIncrCnt) DAQmxGetCOAutoIncrCnt;
int32 __CFUNC DAQmxGetCOAutoIncrCnt(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCOAutoIncrCnt) DAQmxSetCOAutoIncrCnt;
int32 __CFUNC DAQmxSetCOAutoIncrCnt(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCOAutoIncrCnt) DAQmxResetCOAutoIncrCnt;
int32 __CFUNC DAQmxResetCOAutoIncrCnt(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampTimingType Uses value set
 *** SampleTimingType
 ***/
%rename(GetSampTimingType) DAQmxGetSampTimingType;
int32 __CFUNC DAQmxGetSampTimingType(TaskHandle taskHandle, int32 *data);
%rename(SetSampTimingType) DAQmxSetSampTimingType;
int32 __CFUNC DAQmxSetSampTimingType(TaskHandle taskHandle, int32 data);
%rename(ResetSampTimingType) DAQmxResetSampTimingType;
int32 __CFUNC DAQmxResetSampTimingType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AnlgLvl_PauseTrig_Src
 ***/
%rename(GetAnlgLvlPauseTrigSrc) DAQmxGetAnlgLvlPauseTrigSrc;
int32 __CFUNC DAQmxGetAnlgLvlPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgLvlPauseTrigSrc) DAQmxSetAnlgLvlPauseTrigSrc;
int32 __CFUNC DAQmxSetAnlgLvlPauseTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgLvlPauseTrigSrc) DAQmxResetAnlgLvlPauseTrigSrc;
int32 __CFUNC DAQmxResetAnlgLvlPauseTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DI_Tristate
 ***/
%rename(GetDITristate) DAQmxGetDITristate;
int32 __CFUNC DAQmxGetDITristate(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDITristate) DAQmxSetDITristate;
int32 __CFUNC DAQmxSetDITristate(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDITristate) DAQmxResetDITristate;
int32 __CFUNC DAQmxResetDITristate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_RawSampSize
 ***/
%rename(GetAIRawSampSize) DAQmxGetAIRawSampSize;
int32 __CFUNC DAQmxGetAIRawSampSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
/*** Set/Get functions for
 *** DAQmx_SwitchDev_PwrDownLatchRelaysAfterSettling
 ***/
%rename(GetSwitchDevPwrDownLatchRelaysAfterSettling) DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling;
int32 __CFUNC DAQmxGetSwitchDevPwrDownLatchRelaysAfterSettling(const char deviceName[], bool32 *data);
%rename(SetSwitchDevPwrDownLatchRelaysAfterSettling) DAQmxSetSwitchDevPwrDownLatchRelaysAfterSettling;
int32 __CFUNC DAQmxSetSwitchDevPwrDownLatchRelaysAfterSettling(const char deviceName[], bool32 data);
/*** Set/Get functions for DAQmx_CI_Period_DigFltr_MinPulseWidth
 ***/
%rename(GetCIPeriodDigFltrMinPulseWidth) DAQmxGetCIPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCIPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIPeriodDigFltrMinPulseWidth) DAQmxSetCIPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCIPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIPeriodDigFltrMinPulseWidth) DAQmxResetCIPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCIPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_StartTrig_Retriggerable
 ***/
%rename(GetStartTrigRetriggerable) DAQmxGetStartTrigRetriggerable;
int32 __CFUNC DAQmxGetStartTrigRetriggerable(TaskHandle taskHandle, bool32 *data);
%rename(SetStartTrigRetriggerable) DAQmxSetStartTrigRetriggerable;
int32 __CFUNC DAQmxSetStartTrigRetriggerable(TaskHandle taskHandle, bool32 data);
%rename(ResetStartTrigRetriggerable) DAQmxResetStartTrigRetriggerable;
int32 __CFUNC DAQmxResetStartTrigRetriggerable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Bridge_Cfg Uses value set
 *** BridgeConfiguration1
 ***/
%rename(GetAIBridgeCfg) DAQmxGetAIBridgeCfg;
int32 __CFUNC DAQmxGetAIBridgeCfg(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIBridgeCfg) DAQmxSetAIBridgeCfg;
int32 __CFUNC DAQmxSetAIBridgeCfg(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIBridgeCfg) DAQmxResetAIBridgeCfg;
int32 __CFUNC DAQmxResetAIBridgeCfg(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Write_OvertemperatureChansExist
 ***/
%rename(GetWriteOvertemperatureChansExist) DAQmxGetWriteOvertemperatureChansExist;
int32 __CFUNC DAQmxGetWriteOvertemperatureChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_AO_TermCfg Uses value set
 *** OutputTermCfg
 ***/
%rename(GetAOTermCfg) DAQmxGetAOTermCfg;
int32 __CFUNC DAQmxGetAOTermCfg(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAOTermCfg) DAQmxSetAOTermCfg;
int32 __CFUNC DAQmxSetAOTermCfg(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAOTermCfg) DAQmxResetAOTermCfg;
int32 __CFUNC DAQmxResetAOTermCfg(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_WatchdogExpirTrig_Type Uses value set
 *** TriggerType4
 ***/
%rename(GetWatchdogExpirTrigType) DAQmxGetWatchdogExpirTrigType;
int32 __CFUNC DAQmxGetWatchdogExpirTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetWatchdogExpirTrigType) DAQmxSetWatchdogExpirTrigType;
int32 __CFUNC DAQmxSetWatchdogExpirTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetWatchdogExpirTrigType) DAQmxResetWatchdogExpirTrigType;
int32 __CFUNC DAQmxResetWatchdogExpirTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_AutoStart
 ***/
%rename(GetReadAutoStart) DAQmxGetReadAutoStart;
int32 __CFUNC DAQmxGetReadAutoStart(TaskHandle taskHandle, bool32 *data);
%rename(SetReadAutoStart) DAQmxSetReadAutoStart;
int32 __CFUNC DAQmxSetReadAutoStart(TaskHandle taskHandle, bool32 data);
%rename(ResetReadAutoStart) DAQmxResetReadAutoStart;
int32 __CFUNC DAQmxResetReadAutoStart(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AIConv_Timebase_Src Uses value set
 *** MIOAIConvertTbSrc
 ***/
%rename(GetAIConvTimebaseSrc) DAQmxGetAIConvTimebaseSrc;
int32 __CFUNC DAQmxGetAIConvTimebaseSrc(TaskHandle taskHandle, int32 *data);
%rename(SetAIConvTimebaseSrc) DAQmxSetAIConvTimebaseSrc;
int32 __CFUNC DAQmxSetAIConvTimebaseSrc(TaskHandle taskHandle, int32 data);
%rename(ResetAIConvTimebaseSrc) DAQmxResetAIConvTimebaseSrc;
int32 __CFUNC DAQmxResetAIConvTimebaseSrc(TaskHandle taskHandle);
%rename(GetAIConvTimebaseSrcEx) DAQmxGetAIConvTimebaseSrcEx;
int32 __CFUNC DAQmxGetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[], int32 *data);
%rename(SetAIConvTimebaseSrcEx) DAQmxSetAIConvTimebaseSrcEx;
int32 __CFUNC DAQmxSetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[], int32 data);
%rename(ResetAIConvTimebaseSrcEx) DAQmxResetAIConvTimebaseSrcEx;
int32 __CFUNC DAQmxResetAIConvTimebaseSrcEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_Scale_Type Uses value set ScaleType
 ***/
%rename(GetScaleType) DAQmxGetScaleType;
int32 __CFUNC DAQmxGetScaleType(const char scaleName[], int32 *data);
/*** Buffer Set/Get functions for DAQmx_Buf_Input_BufSize
 ***/
%rename(GetBufInputBufSize) DAQmxGetBufInputBufSize;
int32 __CFUNC DAQmxGetBufInputBufSize(TaskHandle taskHandle, uInt32 *data);
%rename(SetBufInputBufSize) DAQmxSetBufInputBufSize;
int32 __CFUNC DAQmxSetBufInputBufSize(TaskHandle taskHandle, uInt32 data);
%rename(ResetBufInputBufSize) DAQmxResetBufInputBufSize;
int32 __CFUNC DAQmxResetBufInputBufSize(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DigPattern_PauseTrig_Src
 ***/
%rename(GetDigPatternPauseTrigSrc) DAQmxGetDigPatternPauseTrigSrc;
int32 __CFUNC DAQmxGetDigPatternPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternPauseTrigSrc) DAQmxSetDigPatternPauseTrigSrc;
int32 __CFUNC DAQmxSetDigPatternPauseTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternPauseTrigSrc) DAQmxResetDigPatternPauseTrigSrc;
int32 __CFUNC DAQmxResetDigPatternPauseTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Write_NumChans
 ***/
%rename(GetWriteNumChans) DAQmxGetWriteNumChans;
int32 __CFUNC DAQmxGetWriteNumChans(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_DigLvl_PauseTrig_DigFltr_TimebaseRate
 ***/
%rename(GetDigLvlPauseTrigDigFltrTimebaseRate) DAQmxGetDigLvlPauseTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 *data);
%rename(SetDigLvlPauseTrigDigFltrTimebaseRate) DAQmxSetDigLvlPauseTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetDigLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle, float64 data);
%rename(ResetDigLvlPauseTrigDigFltrTimebaseRate) DAQmxResetDigLvlPauseTrigDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetDigLvlPauseTrigDigFltrTimebaseRate(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_Exported_RdyForStartEvent_Lvl_ActiveLvl Uses value set
 *** Polarity2
 ***/
%rename(GetExportedRdyForStartEventLvlActiveLvl) DAQmxGetExportedRdyForStartEventLvlActiveLvl;
int32 __CFUNC DAQmxGetExportedRdyForStartEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);
%rename(SetExportedRdyForStartEventLvlActiveLvl) DAQmxSetExportedRdyForStartEventLvlActiveLvl;
int32 __CFUNC DAQmxSetExportedRdyForStartEventLvlActiveLvl(TaskHandle taskHandle, int32 data);
%rename(ResetExportedRdyForStartEventLvlActiveLvl) DAQmxResetExportedRdyForStartEventLvlActiveLvl;
int32 __CFUNC DAQmxResetExportedRdyForStartEventLvlActiveLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SwitchChan_MaxACVoltage
 ***/
%rename(GetSwitchChanMaxACVoltage) DAQmxGetSwitchChanMaxACVoltage;
int32 __CFUNC DAQmxGetSwitchChanMaxACVoltage(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_AI_Voltage_dBRef
 ***/
%rename(GetAIVoltagedBRef) DAQmxGetAIVoltagedBRef;
int32 __CFUNC DAQmxGetAIVoltagedBRef(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIVoltagedBRef) DAQmxSetAIVoltagedBRef;
int32 __CFUNC DAQmxSetAIVoltagedBRef(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIVoltagedBRef) DAQmxResetAIVoltagedBRef;
int32 __CFUNC DAQmxResetAIVoltagedBRef(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Lin_YIntercept
 ***/
%rename(GetScaleLinYIntercept) DAQmxGetScaleLinYIntercept;
int32 __CFUNC DAQmxGetScaleLinYIntercept(const char scaleName[], float64 *data);
%rename(SetScaleLinYIntercept) DAQmxSetScaleLinYIntercept;
int32 __CFUNC DAQmxSetScaleLinYIntercept(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_AO_Min
 ***/
%rename(GetAOMin) DAQmxGetAOMin;
int32 __CFUNC DAQmxGetAOMin(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOMin) DAQmxSetAOMin;
int32 __CFUNC DAQmxSetAOMin(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOMin) DAQmxResetAOMin;
int32 __CFUNC DAQmxResetAOMin(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_CurrentShunt_Loc Uses value set
 *** CurrentShuntResistorLocation1
 ***/
%rename(GetAICurrentShuntLoc) DAQmxGetAICurrentShuntLoc;
int32 __CFUNC DAQmxGetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAICurrentShuntLoc) DAQmxSetAICurrentShuntLoc;
int32 __CFUNC DAQmxSetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAICurrentShuntLoc) DAQmxResetAICurrentShuntLoc;
int32 __CFUNC DAQmxResetAICurrentShuntLoc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Write_OvercurrentChans
 ***/
%rename(GetWriteOvercurrentChans) DAQmxGetWriteOvercurrentChans;
int32 __CFUNC DAQmxGetWriteOvercurrentChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
/*** Export Signal Set/Get functions for
 *** DAQmx_Exported_AIConvClk_OutputTerm
 ***/
%rename(GetExportedAIConvClkOutputTerm) DAQmxGetExportedAIConvClkOutputTerm;
int32 __CFUNC DAQmxGetExportedAIConvClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedAIConvClkOutputTerm) DAQmxSetExportedAIConvClkOutputTerm;
int32 __CFUNC DAQmxSetExportedAIConvClkOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedAIConvClkOutputTerm) DAQmxResetExportedAIConvClkOutputTerm;
int32 __CFUNC DAQmxResetExportedAIConvClkOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Read_CommonModeRangeErrorChansExist
 ***/
%rename(GetReadCommonModeRangeErrorChansExist) DAQmxGetReadCommonModeRangeErrorChansExist;
int32 __CFUNC DAQmxGetReadCommonModeRangeErrorChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_CI_Timestamp_InitialSeconds
 ***/
%rename(GetCITimestampInitialSeconds) DAQmxGetCITimestampInitialSeconds;
int32 __CFUNC DAQmxGetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCITimestampInitialSeconds) DAQmxSetCITimestampInitialSeconds;
int32 __CFUNC DAQmxSetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCITimestampInitialSeconds) DAQmxResetCITimestampInitialSeconds;
int32 __CFUNC DAQmxResetCITimestampInitialSeconds(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Thrmcpl_CJCVal
 ***/
%rename(GetAIThrmcplCJCVal) DAQmxGetAIThrmcplCJCVal;
int32 __CFUNC DAQmxGetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIThrmcplCJCVal) DAQmxSetAIThrmcplCJCVal;
int32 __CFUNC DAQmxSetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIThrmcplCJCVal) DAQmxResetAIThrmcplCJCVal;
int32 __CFUNC DAQmxResetAIThrmcplCJCVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgLvl_PauseTrig_Lvl
 ***/
%rename(GetAnlgLvlPauseTrigLvl) DAQmxGetAnlgLvlPauseTrigLvl;
int32 __CFUNC DAQmxGetAnlgLvlPauseTrigLvl(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgLvlPauseTrigLvl) DAQmxSetAnlgLvlPauseTrigLvl;
int32 __CFUNC DAQmxSetAnlgLvlPauseTrigLvl(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgLvlPauseTrigLvl) DAQmxResetAnlgLvlPauseTrigLvl;
int32 __CFUNC DAQmxResetAnlgLvlPauseTrigLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CtrTimebaseRate
 ***/
%rename(GetCICtrTimebaseRate) DAQmxGetCICtrTimebaseRate;
int32 __CFUNC DAQmxGetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICtrTimebaseRate) DAQmxSetCICtrTimebaseRate;
int32 __CFUNC DAQmxSetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICtrTimebaseRate) DAQmxResetCICtrTimebaseRate;
int32 __CFUNC DAQmxResetCICtrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_CompactDAQ_ChassisDevName
 ***/
%rename(GetDevCompactDAQChassisDevName) DAQmxGetDevCompactDAQChassisDevName;
int32 __CFUNC DAQmxGetDevCompactDAQChassisDevName(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CO_RdyForNewVal
 ***/
%rename(GetCORdyForNewVal) DAQmxGetCORdyForNewVal;
int32 __CFUNC DAQmxGetCORdyForNewVal(TaskHandle taskHandle, const char channel[], bool32 *data);
/*** Set/Get functions for DAQmx_Read_OpenCurrentLoopChansExist
 ***/
%rename(GetReadOpenCurrentLoopChansExist) DAQmxGetReadOpenCurrentLoopChansExist;
int32 __CFUNC DAQmxGetReadOpenCurrentLoopChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for
 *** DAQmx_DigLvl_PauseTrig_DigFltr_MinPulseWidth
 ***/
%rename(GetDigLvlPauseTrigDigFltrMinPulseWidth) DAQmxGetDigLvlPauseTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetDigLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 *data);
%rename(SetDigLvlPauseTrigDigFltrMinPulseWidth) DAQmxSetDigLvlPauseTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetDigLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle, float64 data);
%rename(ResetDigLvlPauseTrigDigFltrMinPulseWidth) DAQmxResetDigLvlPauseTrigDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetDigLvlPauseTrigDigFltrMinPulseWidth(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CountEdges_DigFltr_MinPulseWidth
 ***/
%rename(GetCICountEdgesDigFltrMinPulseWidth) DAQmxGetCICountEdgesDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCICountEdgesDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICountEdgesDigFltrMinPulseWidth) DAQmxSetCICountEdgesDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCICountEdgesDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICountEdgesDigFltrMinPulseWidth) DAQmxResetCICountEdgesDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCICountEdgesDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DigEdge_StartTrig_Edge Uses value set
 *** Edge1
 ***/
%rename(GetDigEdgeStartTrigEdge) DAQmxGetDigEdgeStartTrigEdge;
int32 __CFUNC DAQmxGetDigEdgeStartTrigEdge(TaskHandle taskHandle, int32 *data);
%rename(SetDigEdgeStartTrigEdge) DAQmxSetDigEdgeStartTrigEdge;
int32 __CFUNC DAQmxSetDigEdgeStartTrigEdge(TaskHandle taskHandle, int32 data);
%rename(ResetDigEdgeStartTrigEdge) DAQmxResetDigEdgeStartTrigEdge;
int32 __CFUNC DAQmxResetDigEdgeStartTrigEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_SampClk_OutputTerm
 ***/
%rename(GetExportedSampClkOutputTerm) DAQmxGetExportedSampClkOutputTerm;
int32 __CFUNC DAQmxGetExportedSampClkOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedSampClkOutputTerm) DAQmxSetExportedSampClkOutputTerm;
int32 __CFUNC DAQmxSetExportedSampClkOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedSampClkOutputTerm) DAQmxResetExportedSampClkOutputTerm;
int32 __CFUNC DAQmxResetExportedSampClkOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_TCPIP_WirelessIP
 ***/
%rename(GetDevTCPIPWirelessIP) DAQmxGetDevTCPIPWirelessIP;
int32 __CFUNC DAQmxGetDevTCPIPWirelessIP(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_Second_DigFltr_MinPulseWidth
 ***/
%rename(GetCITwoEdgeSepSecondDigFltrMinPulseWidth) DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCITwoEdgeSepSecondDigFltrMinPulseWidth) DAQmxSetCITwoEdgeSepSecondDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCITwoEdgeSepSecondDigFltrMinPulseWidth) DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DO_LogicFamily Uses value set
 *** LogicFamily
 ***/
%rename(GetDOLogicFamily) DAQmxGetDOLogicFamily;
int32 __CFUNC DAQmxGetDOLogicFamily(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDOLogicFamily) DAQmxSetDOLogicFamily;
int32 __CFUNC DAQmxSetDOLogicFamily(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDOLogicFamily) DAQmxResetDOLogicFamily;
int32 __CFUNC DAQmxResetDOLogicFamily(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_FuncGen_FMDeviation
 ***/
%rename(GetAOFuncGenFMDeviation) DAQmxGetAOFuncGenFMDeviation;
int32 __CFUNC DAQmxGetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOFuncGenFMDeviation) DAQmxSetAOFuncGenFMDeviation;
int32 __CFUNC DAQmxSetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOFuncGenFMDeviation) DAQmxResetAOFuncGenFMDeviation;
int32 __CFUNC DAQmxResetAOFuncGenFMDeviation(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_First_DigFltr_Enable
 ***/
%rename(GetCITwoEdgeSepFirstDigFltrEnable) DAQmxGetCITwoEdgeSepFirstDigFltrEnable;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCITwoEdgeSepFirstDigFltrEnable) DAQmxSetCITwoEdgeSepFirstDigFltrEnable;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCITwoEdgeSepFirstDigFltrEnable) DAQmxResetCITwoEdgeSepFirstDigFltrEnable;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_PauseTrig_Btm
 ***/
%rename(GetAnlgWinPauseTrigBtm) DAQmxGetAnlgWinPauseTrigBtm;
int32 __CFUNC DAQmxGetAnlgWinPauseTrigBtm(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinPauseTrigBtm) DAQmxSetAnlgWinPauseTrigBtm;
int32 __CFUNC DAQmxSetAnlgWinPauseTrigBtm(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinPauseTrigBtm) DAQmxResetAnlgWinPauseTrigBtm;
int32 __CFUNC DAQmxResetAnlgWinPauseTrigBtm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_DAC_Rng_Low
 ***/
%rename(GetAODACRngLow) DAQmxGetAODACRngLow;
int32 __CFUNC DAQmxGetAODACRngLow(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAODACRngLow) DAQmxSetAODACRngLow;
int32 __CFUNC DAQmxSetAODACRngLow(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAODACRngLow) DAQmxResetAODACRngLow;
int32 __CFUNC DAQmxResetAODACRngLow(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_AI_VoltageRngs
 ***/
%rename(GetDevAIVoltageRngs) DAQmxGetDevAIVoltageRngs;
int32 __CFUNC DAQmxGetDevAIVoltageRngs(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_Lowpass_SwitchCap_ExtClkFreq
 ***/
%rename(GetAILowpassSwitchCapExtClkFreq) DAQmxGetAILowpassSwitchCapExtClkFreq;
int32 __CFUNC DAQmxGetAILowpassSwitchCapExtClkFreq(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAILowpassSwitchCapExtClkFreq) DAQmxSetAILowpassSwitchCapExtClkFreq;
int32 __CFUNC DAQmxSetAILowpassSwitchCapExtClkFreq(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAILowpassSwitchCapExtClkFreq) DAQmxResetAILowpassSwitchCapExtClkFreq;
int32 __CFUNC DAQmxResetAILowpassSwitchCapExtClkFreq(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_PauseTrig_Src
 ***/
%rename(GetAnlgWinPauseTrigSrc) DAQmxGetAnlgWinPauseTrigSrc;
int32 __CFUNC DAQmxGetAnlgWinPauseTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAnlgWinPauseTrigSrc) DAQmxSetAnlgWinPauseTrigSrc;
int32 __CFUNC DAQmxSetAnlgWinPauseTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAnlgWinPauseTrigSrc) DAQmxResetAnlgWinPauseTrigSrc;
int32 __CFUNC DAQmxResetAnlgWinPauseTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Lowpass_SwitchCap_ClkSrc Uses
 *** value set SourceSelection
 ***/
%rename(GetAILowpassSwitchCapClkSrc) DAQmxGetAILowpassSwitchCapClkSrc;
int32 __CFUNC DAQmxGetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAILowpassSwitchCapClkSrc) DAQmxSetAILowpassSwitchCapClkSrc;
int32 __CFUNC DAQmxSetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAILowpassSwitchCapClkSrc) DAQmxResetAILowpassSwitchCapClkSrc;
int32 __CFUNC DAQmxResetAILowpassSwitchCapClkSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Voltage_Units Uses value set
 *** VoltageUnits1
 ***/
%rename(GetAIVoltageUnits) DAQmxGetAIVoltageUnits;
int32 __CFUNC DAQmxGetAIVoltageUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIVoltageUnits) DAQmxSetAIVoltageUnits;
int32 __CFUNC DAQmxSetAIVoltageUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIVoltageUnits) DAQmxResetAIVoltageUnits;
int32 __CFUNC DAQmxResetAIVoltageUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_ZInput_DigFltr_TimebaseRate
 ***/
%rename(GetCIEncoderZInputDigFltrTimebaseRate) DAQmxGetCIEncoderZInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIEncoderZInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderZInputDigFltrTimebaseRate) DAQmxSetCIEncoderZInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIEncoderZInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderZInputDigFltrTimebaseRate) DAQmxResetCIEncoderZInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIEncoderZInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Real-Time Set/Get functions for
 *** DAQmx_RealTime_ConvLateErrorsToWarnings
 ***/
%rename(GetRealTimeConvLateErrorsToWarnings) DAQmxGetRealTimeConvLateErrorsToWarnings;
int32 __CFUNC DAQmxGetRealTimeConvLateErrorsToWarnings(TaskHandle taskHandle, bool32 *data);
%rename(SetRealTimeConvLateErrorsToWarnings) DAQmxSetRealTimeConvLateErrorsToWarnings;
int32 __CFUNC DAQmxSetRealTimeConvLateErrorsToWarnings(TaskHandle taskHandle, bool32 data);
%rename(ResetRealTimeConvLateErrorsToWarnings) DAQmxResetRealTimeConvLateErrorsToWarnings;
int32 __CFUNC DAQmxResetRealTimeConvLateErrorsToWarnings(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_Couplings Uses bits from enum
 *** CouplingTypeBits
 ***/
%rename(GetDevAICouplings) DAQmxGetDevAICouplings;
int32 __CFUNC DAQmxGetDevAICouplings(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_Dev_AI_LowpassCutoffFreqRangeVals
 ***/
%rename(GetDevAILowpassCutoffFreqRangeVals) DAQmxGetDevAILowpassCutoffFreqRangeVals;
int32 __CFUNC DAQmxGetDevAILowpassCutoffFreqRangeVals(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_CI_CountEdges_ActiveEdge Uses value
 *** set Edge1
 ***/
%rename(GetCICountEdgesActiveEdge) DAQmxGetCICountEdgesActiveEdge;
int32 __CFUNC DAQmxGetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCICountEdgesActiveEdge) DAQmxSetCICountEdgesActiveEdge;
int32 __CFUNC DAQmxSetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCICountEdgesActiveEdge) DAQmxResetCICountEdgesActiveEdge;
int32 __CFUNC DAQmxResetCICountEdgesActiveEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_PersistedTask_AllowInteractiveDeletion
 ***/
%rename(GetPersistedTaskAllowInteractiveDeletion) DAQmxGetPersistedTaskAllowInteractiveDeletion;
int32 __CFUNC DAQmxGetPersistedTaskAllowInteractiveDeletion(const char taskName[], bool32 *data);

/*** Set/Get functions for DAQmx_Watchdog_DO_ExpirState Uses value set
 *** DigitalLineState
 ***/
%rename(GetWatchdogDOExpirState) DAQmxGetWatchdogDOExpirState;
int32 __CFUNC DAQmxGetWatchdogDOExpirState(TaskHandle taskHandle, const char lines[], int32 *data);
%rename(SetWatchdogDOExpirState) DAQmxSetWatchdogDOExpirState;
int32 __CFUNC DAQmxSetWatchdogDOExpirState(TaskHandle taskHandle, const char lines[], int32 data);
%rename(ResetWatchdogDOExpirState) DAQmxResetWatchdogDOExpirState;
int32 __CFUNC DAQmxResetWatchdogDOExpirState(TaskHandle taskHandle, const char lines[]);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_First_DigSync_Enable
 ***/
%rename(GetCITwoEdgeSepFirstDigSyncEnable) DAQmxGetCITwoEdgeSepFirstDigSyncEnable;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCITwoEdgeSepFirstDigSyncEnable) DAQmxSetCITwoEdgeSepFirstDigSyncEnable;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCITwoEdgeSepFirstDigSyncEnable) DAQmxResetCITwoEdgeSepFirstDigSyncEnable;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Sys_NIDAQMajorVersion
 ***/
%rename(GetSysNIDAQMajorVersion) DAQmxGetSysNIDAQMajorVersion;
int32 __CFUNC DAQmxGetSysNIDAQMajorVersion(uInt32 *data);
/*** Set/Get functions for DAQmx_Exported_CtrOutEvent_OutputTerm
 ***/
%rename(GetExportedCtrOutEventOutputTerm) DAQmxGetExportedCtrOutEventOutputTerm;
int32 __CFUNC DAQmxGetExportedCtrOutEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedCtrOutEventOutputTerm) DAQmxSetExportedCtrOutEventOutputTerm;
int32 __CFUNC DAQmxSetExportedCtrOutEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedCtrOutEventOutputTerm) DAQmxResetExportedCtrOutEventOutputTerm;
int32 __CFUNC DAQmxResetExportedCtrOutEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_DO_Lines
 ***/
%rename(GetDevDOLines) DAQmxGetDevDOLines;
int32 __CFUNC DAQmxGetDevDOLines(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for
 *** DAQmx_PhysicalChan_AO_ManualControlAmplitude
 ***/
%rename(GetPhysicalChanAOManualControlAmplitude) DAQmxGetPhysicalChanAOManualControlAmplitude;
int32 __CFUNC DAQmxGetPhysicalChanAOManualControlAmplitude(const char physicalChannel[], float64 *data);
/*** Set/Get functions for DAQmx_Exported_AdvCmpltEvent_OutputTerm
 ***/
%rename(GetExportedAdvCmpltEventOutputTerm) DAQmxGetExportedAdvCmpltEventOutputTerm;
int32 __CFUNC DAQmxGetExportedAdvCmpltEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedAdvCmpltEventOutputTerm) DAQmxSetExportedAdvCmpltEventOutputTerm;
int32 __CFUNC DAQmxSetExportedAdvCmpltEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedAdvCmpltEventOutputTerm) DAQmxResetExportedAdvCmpltEventOutputTerm;
int32 __CFUNC DAQmxResetExportedAdvCmpltEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_DO_DataXferMech Uses value set
 *** DataTransferMechanism
 ***/
%rename(GetDODataXferMech) DAQmxGetDODataXferMech;
int32 __CFUNC DAQmxGetDODataXferMech(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDODataXferMech) DAQmxSetDODataXferMech;
int32 __CFUNC DAQmxSetDODataXferMech(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDODataXferMech) DAQmxResetDODataXferMech;
int32 __CFUNC DAQmxResetDODataXferMech(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Interlocked_HshkTrig_AssertedLvl Uses
 *** value set Level1
 ***/
%rename(GetInterlockedHshkTrigAssertedLvl) DAQmxGetInterlockedHshkTrigAssertedLvl;
int32 __CFUNC DAQmxGetInterlockedHshkTrigAssertedLvl(TaskHandle taskHandle, int32 *data);
%rename(SetInterlockedHshkTrigAssertedLvl) DAQmxSetInterlockedHshkTrigAssertedLvl;
int32 __CFUNC DAQmxSetInterlockedHshkTrigAssertedLvl(TaskHandle taskHandle, int32 data);
%rename(ResetInterlockedHshkTrigAssertedLvl) DAQmxResetInterlockedHshkTrigAssertedLvl;
int32 __CFUNC DAQmxResetInterlockedHshkTrigAssertedLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_DI_TrigUsage Uses bits from enum
 *** TriggerUsageTypeBits
 ***/
%rename(GetDevDITrigUsage) DAQmxGetDevDITrigUsage;
int32 __CFUNC DAQmxGetDevDITrigUsage(const char device[], int32 *data);
/*** Set/Get functions for DAQmx_CI_CtrTimebaseSrc
 ***/
%rename(GetCICtrTimebaseSrc) DAQmxGetCICtrTimebaseSrc;
int32 __CFUNC DAQmxGetCICtrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCICtrTimebaseSrc) DAQmxSetCICtrTimebaseSrc;
int32 __CFUNC DAQmxSetCICtrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCICtrTimebaseSrc) DAQmxResetCICtrTimebaseSrc;
int32 __CFUNC DAQmxResetCICtrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_MasterTimebase_Src
 ***/
%rename(GetMasterTimebaseSrc) DAQmxGetMasterTimebaseSrc;
int32 __CFUNC DAQmxGetMasterTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetMasterTimebaseSrc) DAQmxSetMasterTimebaseSrc;
int32 __CFUNC DAQmxSetMasterTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetMasterTimebaseSrc) DAQmxResetMasterTimebaseSrc;
int32 __CFUNC DAQmxResetMasterTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_RefTrig_AutoTriggered
 ***/
%rename(GetRefTrigAutoTriggered) DAQmxGetRefTrigAutoTriggered;
int32 __CFUNC DAQmxGetRefTrigAutoTriggered(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_CI_Freq_Term
 ***/
%rename(GetCIFreqTerm) DAQmxGetCIFreqTerm;
int32 __CFUNC DAQmxGetCIFreqTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIFreqTerm) DAQmxSetCIFreqTerm;
int32 __CFUNC DAQmxSetCIFreqTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIFreqTerm) DAQmxResetCIFreqTerm;
int32 __CFUNC DAQmxResetCIFreqTerm(TaskHandle taskHandle, const char channel[]);
/*** Scale Set/Get functions for DAQmx_Scale_Descr
 ***/
%rename(GetScaleDescr) DAQmxGetScaleDescr;
int32 __CFUNC DAQmxGetScaleDescr(const char scaleName[], char *data, uInt32 bufferSize);
%rename(SetScaleDescr) DAQmxSetScaleDescr;
int32 __CFUNC DAQmxSetScaleDescr(const char scaleName[], const char *data);
/*** Set/Get functions for DAQmx_CI_LinEncoder_Units Uses value set
 *** LengthUnits3
 ***/
%rename(GetCILinEncoderUnits) DAQmxGetCILinEncoderUnits;
int32 __CFUNC DAQmxGetCILinEncoderUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCILinEncoderUnits) DAQmxSetCILinEncoderUnits;
int32 __CFUNC DAQmxSetCILinEncoderUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCILinEncoderUnits) DAQmxResetCILinEncoderUnits;
int32 __CFUNC DAQmxResetCILinEncoderUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_PulseWidth_Units Uses value set
 *** TimeUnits3
 ***/
%rename(GetCIPulseWidthUnits) DAQmxGetCIPulseWidthUnits;
int32 __CFUNC DAQmxGetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIPulseWidthUnits) DAQmxSetCIPulseWidthUnits;
int32 __CFUNC DAQmxSetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIPulseWidthUnits) DAQmxResetCIPulseWidthUnits;
int32 __CFUNC DAQmxResetCIPulseWidthUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_InitialCnt
 ***/
%rename(GetCICountEdgesInitialCnt) DAQmxGetCICountEdgesInitialCnt;
int32 __CFUNC DAQmxGetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCICountEdgesInitialCnt) DAQmxSetCICountEdgesInitialCnt;
int32 __CFUNC DAQmxSetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCICountEdgesInitialCnt) DAQmxResetCICountEdgesInitialCnt;
int32 __CFUNC DAQmxResetCICountEdgesInitialCnt(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_LVDT_Sensitivity
 ***/
%rename(GetAILVDTSensitivity) DAQmxGetAILVDTSensitivity;
int32 __CFUNC DAQmxGetAILVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAILVDTSensitivity) DAQmxSetAILVDTSensitivity;
int32 __CFUNC DAQmxSetAILVDTSensitivity(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAILVDTSensitivity) DAQmxResetAILVDTSensitivity;
int32 __CFUNC DAQmxResetAILVDTSensitivity(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_ZIndexPhase Uses value set
 *** EncoderZIndexPhase1
 ***/
%rename(GetCIEncoderZIndexPhase) DAQmxGetCIEncoderZIndexPhase;
int32 __CFUNC DAQmxGetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIEncoderZIndexPhase) DAQmxSetCIEncoderZIndexPhase;
int32 __CFUNC DAQmxSetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIEncoderZIndexPhase) DAQmxResetCIEncoderZIndexPhase;
int32 __CFUNC DAQmxResetCIEncoderZIndexPhase(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_DAC_Ref_ConnToGnd
 ***/
%rename(GetAODACRefConnToGnd) DAQmxGetAODACRefConnToGnd;
int32 __CFUNC DAQmxGetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetAODACRefConnToGnd) DAQmxSetAODACRefConnToGnd;
int32 __CFUNC DAQmxSetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetAODACRefConnToGnd) DAQmxResetAODACRefConnToGnd;
int32 __CFUNC DAQmxResetAODACRefConnToGnd(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgWin_StartTrig_Btm
 ***/
%rename(GetAnlgWinStartTrigBtm) DAQmxGetAnlgWinStartTrigBtm;
int32 __CFUNC DAQmxGetAnlgWinStartTrigBtm(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgWinStartTrigBtm) DAQmxSetAnlgWinStartTrigBtm;
int32 __CFUNC DAQmxSetAnlgWinStartTrigBtm(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgWinStartTrigBtm) DAQmxResetAnlgWinStartTrigBtm;
int32 __CFUNC DAQmxResetAnlgWinStartTrigBtm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Encoder_DecodingType Uses value
 *** set EncoderType2
 ***/
%rename(GetCIEncoderDecodingType) DAQmxGetCIEncoderDecodingType;
int32 __CFUNC DAQmxGetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIEncoderDecodingType) DAQmxSetCIEncoderDecodingType;
int32 __CFUNC DAQmxSetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIEncoderDecodingType) DAQmxResetCIEncoderDecodingType;
int32 __CFUNC DAQmxResetCIEncoderDecodingType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_Offset
 ***/
%rename(GetReadOffset) DAQmxGetReadOffset;
int32 __CFUNC DAQmxGetReadOffset(TaskHandle taskHandle, int32 *data);
%rename(SetReadOffset) DAQmxSetReadOffset;
int32 __CFUNC DAQmxSetReadOffset(TaskHandle taskHandle, int32 data);
%rename(ResetReadOffset) DAQmxResetReadOffset;
int32 __CFUNC DAQmxResetReadOffset(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_CI_Encoder_AInput_DigFltr_TimebaseRate
 ***/
%rename(GetCIEncoderAInputDigFltrTimebaseRate) DAQmxGetCIEncoderAInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCIEncoderAInputDigFltrTimebaseRate) DAQmxSetCIEncoderAInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCIEncoderAInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCIEncoderAInputDigFltrTimebaseRate) DAQmxResetCIEncoderAInputDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_RefTrig_OutputTerm
 ***/
%rename(GetExportedRefTrigOutputTerm) DAQmxGetExportedRefTrigOutputTerm;
int32 __CFUNC DAQmxGetExportedRefTrigOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedRefTrigOutputTerm) DAQmxSetExportedRefTrigOutputTerm;
int32 __CFUNC DAQmxSetExportedRefTrigOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedRefTrigOutputTerm) DAQmxResetExportedRefTrigOutputTerm;
int32 __CFUNC DAQmxResetExportedRefTrigOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Period_Div
 ***/
%rename(GetCIPeriodDiv) DAQmxGetCIPeriodDiv;
int32 __CFUNC DAQmxGetCIPeriodDiv(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCIPeriodDiv) DAQmxSetCIPeriodDiv;
int32 __CFUNC DAQmxSetCIPeriodDiv(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCIPeriodDiv) DAQmxResetCIPeriodDiv;
int32 __CFUNC DAQmxResetCIPeriodDiv(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DI_DigFltr_Enable
 ***/
%rename(GetDIDigFltrEnable) DAQmxGetDIDigFltrEnable;
int32 __CFUNC DAQmxGetDIDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDIDigFltrEnable) DAQmxSetDIDigFltrEnable;
int32 __CFUNC DAQmxSetDIDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDIDigFltrEnable) DAQmxResetDIDigFltrEnable;
int32 __CFUNC DAQmxResetDIDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_20MHzTimebase_OutputTerm
 ***/
%rename(GetExported20MHzTimebaseOutputTerm) DAQmxGetExported20MHzTimebaseOutputTerm;
int32 __CFUNC DAQmxGetExported20MHzTimebaseOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExported20MHzTimebaseOutputTerm) DAQmxSetExported20MHzTimebaseOutputTerm;
int32 __CFUNC DAQmxSetExported20MHzTimebaseOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExported20MHzTimebaseOutputTerm) DAQmxResetExported20MHzTimebaseOutputTerm;
int32 __CFUNC DAQmxResetExported20MHzTimebaseOutputTerm(TaskHandle taskHandle);
/*** Switch Channel Set/Get functions for DAQmx_SwitchChan_Usage Uses
 *** value set SwitchUsageTypes
 ***/
%rename(GetSwitchChanUsage) DAQmxGetSwitchChanUsage;
int32 __CFUNC DAQmxGetSwitchChanUsage(const char switchChannelName[], int32 *data);
%rename(SetSwitchChanUsage) DAQmxSetSwitchChanUsage;
int32 __CFUNC DAQmxSetSwitchChanUsage(const char switchChannelName[], int32 data);
/*** Set/Get functions for DAQmx_DigEdge_RefTrig_Src
 ***/
%rename(GetDigEdgeRefTrigSrc) DAQmxGetDigEdgeRefTrigSrc;
int32 __CFUNC DAQmxGetDigEdgeRefTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeRefTrigSrc) DAQmxSetDigEdgeRefTrigSrc;
int32 __CFUNC DAQmxSetDigEdgeRefTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeRefTrigSrc) DAQmxResetDigEdgeRefTrigSrc;
int32 __CFUNC DAQmxResetDigEdgeRefTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_PhysicalChan_TEDS_BitStream
 ***/
%rename(GetPhysicalChanTEDSBitStream) DAQmxGetPhysicalChanTEDSBitStream;
int32 __CFUNC DAQmxGetPhysicalChanTEDSBitStream(const char physicalChannel[], uInt8 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_MeasType Uses value set
 *** AIMeasurementType
 ***/
%rename(GetAIMeasType) DAQmxGetAIMeasType;
int32 __CFUNC DAQmxGetAIMeasType(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for
 *** DAQmx_Exported_RdyForXferEvent_Lvl_ActiveLvl Uses value set
 *** Polarity2
 ***/
%rename(GetExportedRdyForXferEventLvlActiveLvl) DAQmxGetExportedRdyForXferEventLvlActiveLvl;
int32 __CFUNC DAQmxGetExportedRdyForXferEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);
%rename(SetExportedRdyForXferEventLvlActiveLvl) DAQmxSetExportedRdyForXferEventLvlActiveLvl;
int32 __CFUNC DAQmxSetExportedRdyForXferEventLvlActiveLvl(TaskHandle taskHandle, int32 data);
%rename(ResetExportedRdyForXferEventLvlActiveLvl) DAQmxResetExportedRdyForXferEventLvlActiveLvl;
int32 __CFUNC DAQmxResetExportedRdyForXferEventLvlActiveLvl(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_Exported_HshkEvent_Interlocked_AssertedLvl Uses value set
 *** Level1
 ***/
%rename(GetExportedHshkEventInterlockedAssertedLvl) DAQmxGetExportedHshkEventInterlockedAssertedLvl;
int32 __CFUNC DAQmxGetExportedHshkEventInterlockedAssertedLvl(TaskHandle taskHandle, int32 *data);
%rename(SetExportedHshkEventInterlockedAssertedLvl) DAQmxSetExportedHshkEventInterlockedAssertedLvl;
int32 __CFUNC DAQmxSetExportedHshkEventInterlockedAssertedLvl(TaskHandle taskHandle, int32 data);
%rename(ResetExportedHshkEventInterlockedAssertedLvl) DAQmxResetExportedHshkEventInterlockedAssertedLvl;
int32 __CFUNC DAQmxResetExportedHshkEventInterlockedAssertedLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Task_NumDevices
 ***/
%rename(GetTaskNumDevices) DAQmxGetTaskNumDevices;
int32 __CFUNC DAQmxGetTaskNumDevices(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_Read_OverloadedChansExist
 ***/
%rename(GetReadOverloadedChansExist) DAQmxGetReadOverloadedChansExist;
int32 __CFUNC DAQmxGetReadOverloadedChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_CI_Encoder_ZInputTerm
 ***/
%rename(GetCIEncoderZInputTerm) DAQmxGetCIEncoderZInputTerm;
int32 __CFUNC DAQmxGetCIEncoderZInputTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderZInputTerm) DAQmxSetCIEncoderZInputTerm;
int32 __CFUNC DAQmxSetCIEncoderZInputTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderZInputTerm) DAQmxResetCIEncoderZInputTerm;
int32 __CFUNC DAQmxResetCIEncoderZInputTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Table_ScaledVals
 ***/
%rename(GetScaleTableScaledVals) DAQmxGetScaleTableScaledVals;
int32 __CFUNC DAQmxGetScaleTableScaledVals(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetScaleTableScaledVals) DAQmxSetScaleTableScaledVals;
int32 __CFUNC DAQmxSetScaleTableScaledVals(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_FirstEdge Uses value
 *** set Edge1
 ***/
%rename(GetCITwoEdgeSepFirstEdge) DAQmxGetCITwoEdgeSepFirstEdge;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCITwoEdgeSepFirstEdge) DAQmxSetCITwoEdgeSepFirstEdge;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCITwoEdgeSepFirstEdge) DAQmxResetCITwoEdgeSepFirstEdge;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstEdge(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Write_WaitMode Uses value set
 *** WaitMode2
 ***/
%rename(GetWriteWaitMode) DAQmxGetWriteWaitMode;
int32 __CFUNC DAQmxGetWriteWaitMode(TaskHandle taskHandle, int32 *data);
%rename(SetWriteWaitMode) DAQmxSetWriteWaitMode;
int32 __CFUNC DAQmxSetWriteWaitMode(TaskHandle taskHandle, int32 data);
%rename(ResetWriteWaitMode) DAQmxResetWriteWaitMode;
int32 __CFUNC DAQmxResetWriteWaitMode(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Freq_DigFltr_TimebaseSrc
 ***/
%rename(GetCIFreqDigFltrTimebaseSrc) DAQmxGetCIFreqDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIFreqDigFltrTimebaseSrc) DAQmxSetCIFreqDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIFreqDigFltrTimebaseSrc) DAQmxResetCIFreqDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIFreqDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AIConv_Src
 ***/
%rename(GetAIConvSrc) DAQmxGetAIConvSrc;
int32 __CFUNC DAQmxGetAIConvSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetAIConvSrc) DAQmxSetAIConvSrc;
int32 __CFUNC DAQmxSetAIConvSrc(TaskHandle taskHandle, const char *data);
%rename(ResetAIConvSrc) DAQmxResetAIConvSrc;
int32 __CFUNC DAQmxResetAIConvSrc(TaskHandle taskHandle);
%rename(GetAIConvSrcEx) DAQmxGetAIConvSrcEx;
int32 __CFUNC DAQmxGetAIConvSrcEx(TaskHandle taskHandle, const char deviceNames[], char *data, uInt32 bufferSize);
%rename(SetAIConvSrcEx) DAQmxSetAIConvSrcEx;
int32 __CFUNC DAQmxSetAIConvSrcEx(TaskHandle taskHandle, const char deviceNames[], const char *data);
%rename(ResetAIConvSrcEx) DAQmxResetAIConvSrcEx;
int32 __CFUNC DAQmxResetAIConvSrcEx(TaskHandle taskHandle, const char deviceNames[]);
/*** Set/Get functions for DAQmx_CI_Encoder_AInput_DigFltr_Enable
 ***/
%rename(GetCIEncoderAInputDigFltrEnable) DAQmxGetCIEncoderAInputDigFltrEnable;
int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIEncoderAInputDigFltrEnable) DAQmxSetCIEncoderAInputDigFltrEnable;
int32 __CFUNC DAQmxSetCIEncoderAInputDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIEncoderAInputDigFltrEnable) DAQmxResetCIEncoderAInputDigFltrEnable;
int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Read_OvercurrentChansExist
 ***/
%rename(GetReadOvercurrentChansExist) DAQmxGetReadOvercurrentChansExist;
int32 __CFUNC DAQmxGetReadOvercurrentChansExist(TaskHandle taskHandle, bool32 *data);
/*** Set/Get functions for DAQmx_AI_Freq_Units Uses value set
 *** FrequencyUnits
 ***/
%rename(GetAIFreqUnits) DAQmxGetAIFreqUnits;
int32 __CFUNC DAQmxGetAIFreqUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIFreqUnits) DAQmxSetAIFreqUnits;
int32 __CFUNC DAQmxSetAIFreqUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIFreqUnits) DAQmxResetAIFreqUnits;
int32 __CFUNC DAQmxResetAIFreqUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Accel_SensitivityUnits Uses value
 *** set AccelSensitivityUnits1
 ***/
%rename(GetAIAccelSensitivityUnits) DAQmxGetAIAccelSensitivityUnits;
int32 __CFUNC DAQmxGetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIAccelSensitivityUnits) DAQmxSetAIAccelSensitivityUnits;
int32 __CFUNC DAQmxSetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIAccelSensitivityUnits) DAQmxResetAIAccelSensitivityUnits;
int32 __CFUNC DAQmxResetAIAccelSensitivityUnits(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CO_CtrTimebase_DigSync_Enable
 ***/
%rename(GetCOCtrTimebaseDigSyncEnable) DAQmxGetCOCtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxGetCOCtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCOCtrTimebaseDigSyncEnable) DAQmxSetCOCtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxSetCOCtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCOCtrTimebaseDigSyncEnable) DAQmxResetCOCtrTimebaseDigSyncEnable;
int32 __CFUNC DAQmxResetCOCtrTimebaseDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Exported_HshkEvent_Pulse_Polarity
 *** Uses value set Polarity2
 ***/
%rename(GetExportedHshkEventPulsePolarity) DAQmxGetExportedHshkEventPulsePolarity;
int32 __CFUNC DAQmxGetExportedHshkEventPulsePolarity(TaskHandle taskHandle, int32 *data);
%rename(SetExportedHshkEventPulsePolarity) DAQmxSetExportedHshkEventPulsePolarity;
int32 __CFUNC DAQmxSetExportedHshkEventPulsePolarity(TaskHandle taskHandle, int32 data);
%rename(ResetExportedHshkEventPulsePolarity) DAQmxResetExportedHshkEventPulsePolarity;
int32 __CFUNC DAQmxResetExportedHshkEventPulsePolarity(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Excit_Src Uses value set
 *** ExcitationSource
 ***/
%rename(GetAIExcitSrc) DAQmxGetAIExcitSrc;
int32 __CFUNC DAQmxGetAIExcitSrc(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIExcitSrc) DAQmxSetAIExcitSrc;
int32 __CFUNC DAQmxSetAIExcitSrc(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIExcitSrc) DAQmxResetAIExcitSrc;
int32 __CFUNC DAQmxResetAIExcitSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_ActiveEdge Uses value set
 *** Edge1
 ***/
%rename(GetSampClkActiveEdge) DAQmxGetSampClkActiveEdge;
int32 __CFUNC DAQmxGetSampClkActiveEdge(TaskHandle taskHandle, int32 *data);
%rename(SetSampClkActiveEdge) DAQmxSetSampClkActiveEdge;
int32 __CFUNC DAQmxSetSampClkActiveEdge(TaskHandle taskHandle, int32 data);
%rename(ResetSampClkActiveEdge) DAQmxResetSampClkActiveEdge;
int32 __CFUNC DAQmxResetSampClkActiveEdge(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Task_NumChans
 ***/
%rename(GetTaskNumChans) DAQmxGetTaskNumChans;
int32 __CFUNC DAQmxGetTaskNumChans(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_AI_SoundPressure_dBRef
 ***/
%rename(GetAISoundPressuredBRef) DAQmxGetAISoundPressuredBRef;
int32 __CFUNC DAQmxGetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAISoundPressuredBRef) DAQmxSetAISoundPressuredBRef;
int32 __CFUNC DAQmxSetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAISoundPressuredBRef) DAQmxResetAISoundPressuredBRef;
int32 __CFUNC DAQmxResetAISoundPressuredBRef(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_StrainGage_PoissonRatio
 ***/
%rename(GetAIStrainGagePoissonRatio) DAQmxGetAIStrainGagePoissonRatio;
int32 __CFUNC DAQmxGetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIStrainGagePoissonRatio) DAQmxSetAIStrainGagePoissonRatio;
int32 __CFUNC DAQmxSetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIStrainGagePoissonRatio) DAQmxResetAIStrainGagePoissonRatio;
int32 __CFUNC DAQmxResetAIStrainGagePoissonRatio(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Map_PreScaledMax
 ***/
%rename(GetScaleMapPreScaledMax) DAQmxGetScaleMapPreScaledMax;
int32 __CFUNC DAQmxGetScaleMapPreScaledMax(const char scaleName[], float64 *data);
%rename(SetScaleMapPreScaledMax) DAQmxSetScaleMapPreScaledMax;
int32 __CFUNC DAQmxSetScaleMapPreScaledMax(const char scaleName[], float64 data);
/*** Set/Get functions for DAQmx_AnlgWin_RefTrig_Coupling Uses value
 *** set Coupling2
 ***/
%rename(GetAnlgWinRefTrigCoupling) DAQmxGetAnlgWinRefTrigCoupling;
int32 __CFUNC DAQmxGetAnlgWinRefTrigCoupling(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgWinRefTrigCoupling) DAQmxSetAnlgWinRefTrigCoupling;
int32 __CFUNC DAQmxSetAnlgWinRefTrigCoupling(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgWinRefTrigCoupling) DAQmxResetAnlgWinRefTrigCoupling;
int32 __CFUNC DAQmxResetAnlgWinRefTrigCoupling(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_ArmStartTrig_Type Uses value set
 *** TriggerType4
 ***/
%rename(GetArmStartTrigType) DAQmxGetArmStartTrigType;
int32 __CFUNC DAQmxGetArmStartTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetArmStartTrigType) DAQmxSetArmStartTrigType;
int32 __CFUNC DAQmxSetArmStartTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetArmStartTrigType) DAQmxResetArmStartTrigType;
int32 __CFUNC DAQmxResetArmStartTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_PauseTrig_Type Uses value set
 *** TriggerType6
 ***/
%rename(GetPauseTrigType) DAQmxGetPauseTrigType;
int32 __CFUNC DAQmxGetPauseTrigType(TaskHandle taskHandle, int32 *data);
%rename(SetPauseTrigType) DAQmxSetPauseTrigType;
int32 __CFUNC DAQmxSetPauseTrigType(TaskHandle taskHandle, int32 data);
%rename(ResetPauseTrigType) DAQmxResetPauseTrigType;
int32 __CFUNC DAQmxResetPauseTrigType(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_CtrTimebase_DigFltr_TimebaseRate
 ***/
%rename(GetCICtrTimebaseDigFltrTimebaseRate) DAQmxGetCICtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCICtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCICtrTimebaseDigFltrTimebaseRate) DAQmxSetCICtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCICtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCICtrTimebaseDigFltrTimebaseRate) DAQmxResetCICtrTimebaseDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCICtrTimebaseDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_Second_DigFltr_TimebaseRate
 ***/
%rename(GetCITwoEdgeSepSecondDigFltrTimebaseRate) DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCITwoEdgeSepSecondDigFltrTimebaseRate) DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseRate;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCITwoEdgeSepSecondDigFltrTimebaseRate) DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondDigFltrTimebaseRate(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_FuncGen_Square_DutyCycle
 ***/
%rename(GetAOFuncGenSquareDutyCycle) DAQmxGetAOFuncGenSquareDutyCycle;
int32 __CFUNC DAQmxGetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAOFuncGenSquareDutyCycle) DAQmxSetAOFuncGenSquareDutyCycle;
int32 __CFUNC DAQmxSetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAOFuncGenSquareDutyCycle) DAQmxResetAOFuncGenSquareDutyCycle;
int32 __CFUNC DAQmxResetAOFuncGenSquareDutyCycle(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_ChangeDetect_DI_FallingEdgePhysicalChans
 ***/
%rename(GetChangeDetectDIFallingEdgePhysicalChans) DAQmxGetChangeDetectDIFallingEdgePhysicalChans;
int32 __CFUNC DAQmxGetChangeDetectDIFallingEdgePhysicalChans(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetChangeDetectDIFallingEdgePhysicalChans) DAQmxSetChangeDetectDIFallingEdgePhysicalChans;
int32 __CFUNC DAQmxSetChangeDetectDIFallingEdgePhysicalChans(TaskHandle taskHandle, const char *data);
%rename(ResetChangeDetectDIFallingEdgePhysicalChans) DAQmxResetChangeDetectDIFallingEdgePhysicalChans;
int32 __CFUNC DAQmxResetChangeDetectDIFallingEdgePhysicalChans(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_ChanCal_Verif_AcqVals
 ***/
%rename(GetAIChanCalVerifAcqVals) DAQmxGetAIChanCalVerifAcqVals;
int32 __CFUNC DAQmxGetAIChanCalVerifAcqVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetAIChanCalVerifAcqVals) DAQmxSetAIChanCalVerifAcqVals;
int32 __CFUNC DAQmxSetAIChanCalVerifAcqVals(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
%rename(ResetAIChanCalVerifAcqVals) DAQmxResetAIChanCalVerifAcqVals;
int32 __CFUNC DAQmxResetAIChanCalVerifAcqVals(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_AInputTerm
 ***/
%rename(GetCIEncoderAInputTerm) DAQmxGetCIEncoderAInputTerm;
int32 __CFUNC DAQmxGetCIEncoderAInputTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderAInputTerm) DAQmxSetCIEncoderAInputTerm;
int32 __CFUNC DAQmxSetCIEncoderAInputTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderAInputTerm) DAQmxResetCIEncoderAInputTerm;
int32 __CFUNC DAQmxResetCIEncoderAInputTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Bridge_Balance_CoarsePot
 ***/
%rename(GetAIBridgeBalanceCoarsePot) DAQmxGetAIBridgeBalanceCoarsePot;
int32 __CFUNC DAQmxGetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIBridgeBalanceCoarsePot) DAQmxSetAIBridgeBalanceCoarsePot;
int32 __CFUNC DAQmxSetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIBridgeBalanceCoarsePot) DAQmxResetAIBridgeBalanceCoarsePot;
int32 __CFUNC DAQmxResetAIBridgeBalanceCoarsePot(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AnlgEdge_RefTrig_Hyst
 ***/
%rename(GetAnlgEdgeRefTrigHyst) DAQmxGetAnlgEdgeRefTrigHyst;
int32 __CFUNC DAQmxGetAnlgEdgeRefTrigHyst(TaskHandle taskHandle, float64 *data);
%rename(SetAnlgEdgeRefTrigHyst) DAQmxSetAnlgEdgeRefTrigHyst;
int32 __CFUNC DAQmxSetAnlgEdgeRefTrigHyst(TaskHandle taskHandle, float64 data);
%rename(ResetAnlgEdgeRefTrigHyst) DAQmxResetAnlgEdgeRefTrigHyst;
int32 __CFUNC DAQmxResetAnlgEdgeRefTrigHyst(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AO_OutputType Uses value set
 *** AOOutputChannelType
 ***/
%rename(GetAOOutputType) DAQmxGetAOOutputType;
int32 __CFUNC DAQmxGetAOOutputType(TaskHandle taskHandle, const char channel[], int32 *data);
/*** Set/Get functions for DAQmx_DigPattern_StartTrig_Src
 ***/
%rename(GetDigPatternStartTrigSrc) DAQmxGetDigPatternStartTrigSrc;
int32 __CFUNC DAQmxGetDigPatternStartTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigPatternStartTrigSrc) DAQmxSetDigPatternStartTrigSrc;
int32 __CFUNC DAQmxSetDigPatternStartTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigPatternStartTrigSrc) DAQmxResetDigPatternStartTrigSrc;
int32 __CFUNC DAQmxResetDigPatternStartTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for
 *** DAQmx_CI_TwoEdgeSep_First_DigFltr_MinPulseWidth
 ***/
%rename(GetCITwoEdgeSepFirstDigFltrMinPulseWidth) DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCITwoEdgeSepFirstDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCITwoEdgeSepFirstDigFltrMinPulseWidth) DAQmxSetCITwoEdgeSepFirstDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCITwoEdgeSepFirstDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCITwoEdgeSepFirstDigFltrMinPulseWidth) DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCITwoEdgeSepFirstDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_Encoder_AInput_DigFltr_TimebaseSrc
 ***/
%rename(GetCIEncoderAInputDigFltrTimebaseSrc) DAQmxGetCIEncoderAInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxGetCIEncoderAInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderAInputDigFltrTimebaseSrc) DAQmxSetCIEncoderAInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxSetCIEncoderAInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderAInputDigFltrTimebaseSrc) DAQmxResetCIEncoderAInputDigFltrTimebaseSrc;
int32 __CFUNC DAQmxResetCIEncoderAInputDigFltrTimebaseSrc(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AO_DAC_Offset_Val
 ***/
%rename(GetAODACOffsetVal) DAQmxGetAODACOffsetVal;
int32 __CFUNC DAQmxGetAODACOffsetVal(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAODACOffsetVal) DAQmxSetAODACOffsetVal;
int32 __CFUNC DAQmxSetAODACOffsetVal(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAODACOffsetVal) DAQmxResetAODACOffsetVal;
int32 __CFUNC DAQmxResetAODACOffsetVal(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_TwoEdgeSep_SecondTerm
 ***/
%rename(GetCITwoEdgeSepSecondTerm) DAQmxGetCITwoEdgeSepSecondTerm;
int32 __CFUNC DAQmxGetCITwoEdgeSepSecondTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCITwoEdgeSepSecondTerm) DAQmxSetCITwoEdgeSepSecondTerm;
int32 __CFUNC DAQmxSetCITwoEdgeSepSecondTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCITwoEdgeSepSecondTerm) DAQmxResetCITwoEdgeSepSecondTerm;
int32 __CFUNC DAQmxResetCITwoEdgeSepSecondTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Dev_ProductType
 ***/
%rename(GetDevProductType) DAQmxGetDevProductType;
int32 __CFUNC DAQmxGetDevProductType(const char device[], char *data, uInt32 bufferSize);
/*** Set/Get functions for DAQmx_CI_Period_MeasMeth Uses value set
 *** CounterFrequencyMethod
 ***/
%rename(GetCIPeriodMeasMeth) DAQmxGetCIPeriodMeasMeth;
int32 __CFUNC DAQmxGetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetCIPeriodMeasMeth) DAQmxSetCIPeriodMeasMeth;
int32 __CFUNC DAQmxSetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetCIPeriodMeasMeth) DAQmxResetCIPeriodMeasMeth;
int32 __CFUNC DAQmxResetCIPeriodMeasMeth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_ChanIsGlobal
 ***/
%rename(GetChanIsGlobal) DAQmxGetChanIsGlobal;
int32 __CFUNC DAQmxGetChanIsGlobal(TaskHandle taskHandle, const char channel[], bool32 *data);

/*** Set/Get functions for DAQmx_AnlgEdge_StartTrig_Slope Uses value
 *** set Slope1
 ***/
%rename(GetAnlgEdgeStartTrigSlope) DAQmxGetAnlgEdgeStartTrigSlope;
int32 __CFUNC DAQmxGetAnlgEdgeStartTrigSlope(TaskHandle taskHandle, int32 *data);
%rename(SetAnlgEdgeStartTrigSlope) DAQmxSetAnlgEdgeStartTrigSlope;
int32 __CFUNC DAQmxSetAnlgEdgeStartTrigSlope(TaskHandle taskHandle, int32 data);
%rename(ResetAnlgEdgeStartTrigSlope) DAQmxResetAnlgEdgeStartTrigSlope;
int32 __CFUNC DAQmxResetAnlgEdgeStartTrigSlope(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_AI_Thrmcpl_Type Uses value set
 *** ThermocoupleType1
 ***/
%rename(GetAIThrmcplType) DAQmxGetAIThrmcplType;
int32 __CFUNC DAQmxGetAIThrmcplType(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetAIThrmcplType) DAQmxSetAIThrmcplType;
int32 __CFUNC DAQmxSetAIThrmcplType(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetAIThrmcplType) DAQmxResetAIThrmcplType;
int32 __CFUNC DAQmxResetAIThrmcplType(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_Exported_DataActiveEvent_Lvl_ActiveLvl Uses value set
 *** Polarity2
 ***/
%rename(GetExportedDataActiveEventLvlActiveLvl) DAQmxGetExportedDataActiveEventLvlActiveLvl;
int32 __CFUNC DAQmxGetExportedDataActiveEventLvlActiveLvl(TaskHandle taskHandle, int32 *data);
%rename(SetExportedDataActiveEventLvlActiveLvl) DAQmxSetExportedDataActiveEventLvlActiveLvl;
int32 __CFUNC DAQmxSetExportedDataActiveEventLvlActiveLvl(TaskHandle taskHandle, int32 data);
%rename(ResetExportedDataActiveEventLvlActiveLvl) DAQmxResetExportedDataActiveEventLvlActiveLvl;
int32 __CFUNC DAQmxResetExportedDataActiveEventLvlActiveLvl(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Dev_AI_Gains
 ***/
%rename(GetDevAIGains) DAQmxGetDevAIGains;
int32 __CFUNC DAQmxGetDevAIGains(const char device[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_AI_DevScalingCoeff
 ***/
%rename(GetAIDevScalingCoeff) DAQmxGetAIDevScalingCoeff;
int32 __CFUNC DAQmxGetAIDevScalingCoeff(TaskHandle taskHandle, const char channel[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_Scale_Poly_ForwardCoeff
 ***/
%rename(GetScalePolyForwardCoeff) DAQmxGetScalePolyForwardCoeff;
int32 __CFUNC DAQmxGetScalePolyForwardCoeff(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetScalePolyForwardCoeff) DAQmxSetScalePolyForwardCoeff;
int32 __CFUNC DAQmxSetScalePolyForwardCoeff(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
/*** Set/Get functions for DAQmx_DO_DataXferReqCond Uses value set
 *** OutputDataTransferCondition
 ***/
%rename(GetDODataXferReqCond) DAQmxGetDODataXferReqCond;
int32 __CFUNC DAQmxGetDODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 *data);
%rename(SetDODataXferReqCond) DAQmxSetDODataXferReqCond;
int32 __CFUNC DAQmxSetDODataXferReqCond(TaskHandle taskHandle, const char channel[], int32 data);
%rename(ResetDODataXferReqCond) DAQmxResetDODataXferReqCond;
int32 __CFUNC DAQmxResetDODataXferReqCond(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_AI_Bridge_ShuntCal_GainAdjust
 ***/
%rename(GetAIBridgeShuntCalGainAdjust) DAQmxGetAIBridgeShuntCalGainAdjust;
int32 __CFUNC DAQmxGetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetAIBridgeShuntCalGainAdjust) DAQmxSetAIBridgeShuntCalGainAdjust;
int32 __CFUNC DAQmxSetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetAIBridgeShuntCalGainAdjust) DAQmxResetAIBridgeShuntCalGainAdjust;
int32 __CFUNC DAQmxResetAIBridgeShuntCalGainAdjust(TaskHandle taskHandle, const char channel[]);
/*** Write Set/Get functions for DAQmx_Write_RelativeTo Uses value set
 *** WriteRelativeTo
 ***/
%rename(GetWriteRelativeTo) DAQmxGetWriteRelativeTo;
int32 __CFUNC DAQmxGetWriteRelativeTo(TaskHandle taskHandle, int32 *data);
%rename(SetWriteRelativeTo) DAQmxSetWriteRelativeTo;
int32 __CFUNC DAQmxSetWriteRelativeTo(TaskHandle taskHandle, int32 data);
%rename(ResetWriteRelativeTo) DAQmxResetWriteRelativeTo;
int32 __CFUNC DAQmxResetWriteRelativeTo(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SwitchChan_Impedance
 ***/
%rename(GetSwitchChanImpedance) DAQmxGetSwitchChanImpedance;
int32 __CFUNC DAQmxGetSwitchChanImpedance(const char switchChannelName[], float64 *data);

/*** Set/Get functions for DAQmx_SwitchChan_MaxDCCarryCurrent
 ***/
%rename(GetSwitchChanMaxDCCarryCurrent) DAQmxGetSwitchChanMaxDCCarryCurrent;
int32 __CFUNC DAQmxGetSwitchChanMaxDCCarryCurrent(const char switchChannelName[], float64 *data);
/*** Set/Get functions for DAQmx_Write_NextWriteIsLast
 ***/
%rename(GetWriteNextWriteIsLast) DAQmxGetWriteNextWriteIsLast;
int32 __CFUNC DAQmxGetWriteNextWriteIsLast(TaskHandle taskHandle, bool32 *data);
%rename(SetWriteNextWriteIsLast) DAQmxSetWriteNextWriteIsLast;
int32 __CFUNC DAQmxSetWriteNextWriteIsLast(TaskHandle taskHandle, bool32 data);
%rename(ResetWriteNextWriteIsLast) DAQmxResetWriteNextWriteIsLast;
int32 __CFUNC DAQmxResetWriteNextWriteIsLast(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampClk_DigFltr_Enable
 ***/
%rename(GetSampClkDigFltrEnable) DAQmxGetSampClkDigFltrEnable;
int32 __CFUNC DAQmxGetSampClkDigFltrEnable(TaskHandle taskHandle, bool32 *data);
%rename(SetSampClkDigFltrEnable) DAQmxSetSampClkDigFltrEnable;
int32 __CFUNC DAQmxSetSampClkDigFltrEnable(TaskHandle taskHandle, bool32 data);
%rename(ResetSampClkDigFltrEnable) DAQmxResetSampClkDigFltrEnable;
int32 __CFUNC DAQmxResetSampClkDigFltrEnable(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_SemiPeriod_DigFltr_MinPulseWidth
 ***/
%rename(GetCISemiPeriodDigFltrMinPulseWidth) DAQmxGetCISemiPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxGetCISemiPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCISemiPeriodDigFltrMinPulseWidth) DAQmxSetCISemiPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxSetCISemiPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCISemiPeriodDigFltrMinPulseWidth) DAQmxResetCISemiPeriodDigFltrMinPulseWidth;
int32 __CFUNC DAQmxResetCISemiPeriodDigFltrMinPulseWidth(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_SampClk_Timebase_Src
 ***/
%rename(GetSampClkTimebaseSrc) DAQmxGetSampClkTimebaseSrc;
int32 __CFUNC DAQmxGetSampClkTimebaseSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetSampClkTimebaseSrc) DAQmxSetSampClkTimebaseSrc;
int32 __CFUNC DAQmxSetSampClkTimebaseSrc(TaskHandle taskHandle, const char *data);
%rename(ResetSampClkTimebaseSrc) DAQmxResetSampClkTimebaseSrc;
int32 __CFUNC DAQmxResetSampClkTimebaseSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_UsbXferReqSize
 ***/
%rename(GetCIUsbXferReqSize) DAQmxGetCIUsbXferReqSize;
int32 __CFUNC DAQmxGetCIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 *data);
%rename(SetCIUsbXferReqSize) DAQmxSetCIUsbXferReqSize;
int32 __CFUNC DAQmxSetCIUsbXferReqSize(TaskHandle taskHandle, const char channel[], uInt32 data);
%rename(ResetCIUsbXferReqSize) DAQmxResetCIUsbXferReqSize;
int32 __CFUNC DAQmxResetCIUsbXferReqSize(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_PhysicalChanName
 ***/
%rename(GetPhysicalChanName) DAQmxGetPhysicalChanName;
int32 __CFUNC DAQmxGetPhysicalChanName(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetPhysicalChanName) DAQmxSetPhysicalChanName;
int32 __CFUNC DAQmxSetPhysicalChanName(TaskHandle taskHandle, const char channel[], const char *data);
/*** Set/Get functions for DAQmx_SampClk_UnderflowBehavior Uses value
 *** set UnderflowBehavior
 ***/
%rename(GetSampClkUnderflowBehavior) DAQmxGetSampClkUnderflowBehavior;
int32 __CFUNC DAQmxGetSampClkUnderflowBehavior(TaskHandle taskHandle, int32 *data);
%rename(SetSampClkUnderflowBehavior) DAQmxSetSampClkUnderflowBehavior;
int32 __CFUNC DAQmxSetSampClkUnderflowBehavior(TaskHandle taskHandle, int32 data);
%rename(ResetSampClkUnderflowBehavior) DAQmxResetSampClkUnderflowBehavior;
int32 __CFUNC DAQmxResetSampClkUnderflowBehavior(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CO_Pulse_LowTime
 ***/
%rename(GetCOPulseLowTime) DAQmxGetCOPulseLowTime;
int32 __CFUNC DAQmxGetCOPulseLowTime(TaskHandle taskHandle, const char channel[], float64 *data);
%rename(SetCOPulseLowTime) DAQmxSetCOPulseLowTime;
int32 __CFUNC DAQmxSetCOPulseLowTime(TaskHandle taskHandle, const char channel[], float64 data);
%rename(ResetCOPulseLowTime) DAQmxResetCOPulseLowTime;
int32 __CFUNC DAQmxResetCOPulseLowTime(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_DI_InvertLines
 ***/
%rename(GetDIInvertLines) DAQmxGetDIInvertLines;
int32 __CFUNC DAQmxGetDIInvertLines(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetDIInvertLines) DAQmxSetDIInvertLines;
int32 __CFUNC DAQmxSetDIInvertLines(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetDIInvertLines) DAQmxResetDIInvertLines;
int32 __CFUNC DAQmxResetDIInvertLines(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_CI_CountEdges_DigFltr_Enable
 ***/
%rename(GetCICountEdgesDigFltrEnable) DAQmxGetCICountEdgesDigFltrEnable;
int32 __CFUNC DAQmxGetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCICountEdgesDigFltrEnable) DAQmxSetCICountEdgesDigFltrEnable;
int32 __CFUNC DAQmxSetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCICountEdgesDigFltrEnable) DAQmxResetCICountEdgesDigFltrEnable;
int32 __CFUNC DAQmxResetCICountEdgesDigFltrEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Scale_Table_PreScaledVals
 ***/
%rename(GetScaleTablePreScaledVals) DAQmxGetScaleTablePreScaledVals;
int32 __CFUNC DAQmxGetScaleTablePreScaledVals(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);
%rename(SetScaleTablePreScaledVals) DAQmxSetScaleTablePreScaledVals;
int32 __CFUNC DAQmxSetScaleTablePreScaledVals(const char scaleName[], float64 *data, uInt32 arraySizeInSamples);

/*** Set/Get functions for DAQmx_DigEdge_AdvTrig_Src
 ***/
%rename(GetDigEdgeAdvTrigSrc) DAQmxGetDigEdgeAdvTrigSrc;
int32 __CFUNC DAQmxGetDigEdgeAdvTrigSrc(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetDigEdgeAdvTrigSrc) DAQmxSetDigEdgeAdvTrigSrc;
int32 __CFUNC DAQmxSetDigEdgeAdvTrigSrc(TaskHandle taskHandle, const char *data);
%rename(ResetDigEdgeAdvTrigSrc) DAQmxResetDigEdgeAdvTrigSrc;
int32 __CFUNC DAQmxResetDigEdgeAdvTrigSrc(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_CI_Encoder_BInputTerm
 ***/
%rename(GetCIEncoderBInputTerm) DAQmxGetCIEncoderBInputTerm;
int32 __CFUNC DAQmxGetCIEncoderBInputTerm(TaskHandle taskHandle, const char channel[], char *data, uInt32 bufferSize);
%rename(SetCIEncoderBInputTerm) DAQmxSetCIEncoderBInputTerm;
int32 __CFUNC DAQmxSetCIEncoderBInputTerm(TaskHandle taskHandle, const char channel[], const char *data);
%rename(ResetCIEncoderBInputTerm) DAQmxResetCIEncoderBInputTerm;
int32 __CFUNC DAQmxResetCIEncoderBInputTerm(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for DAQmx_Buf_Input_OnbrdBufSize
 ***/
%rename(GetBufInputOnbrdBufSize) DAQmxGetBufInputOnbrdBufSize;
int32 __CFUNC DAQmxGetBufInputOnbrdBufSize(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_Read_DigitalLines_BytesPerChan
 ***/
%rename(GetReadDigitalLinesBytesPerChan) DAQmxGetReadDigitalLinesBytesPerChan;
int32 __CFUNC DAQmxGetReadDigitalLinesBytesPerChan(TaskHandle taskHandle, uInt32 *data);
/*** Set/Get functions for DAQmx_CI_Freq_DigSync_Enable
 ***/
%rename(GetCIFreqDigSyncEnable) DAQmxGetCIFreqDigSyncEnable;
int32 __CFUNC DAQmxGetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 *data);
%rename(SetCIFreqDigSyncEnable) DAQmxSetCIFreqDigSyncEnable;
int32 __CFUNC DAQmxSetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[], bool32 data);
%rename(ResetCIFreqDigSyncEnable) DAQmxResetCIFreqDigSyncEnable;
int32 __CFUNC DAQmxResetCIFreqDigSyncEnable(TaskHandle taskHandle, const char channel[]);
/*** Set/Get functions for
 *** DAQmx_Exported_DividedSampClkTimebase_OutputTerm
 ***/
%rename(GetExportedDividedSampClkTimebaseOutputTerm) DAQmxGetExportedDividedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxGetExportedDividedSampClkTimebaseOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedDividedSampClkTimebaseOutputTerm) DAQmxSetExportedDividedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxSetExportedDividedSampClkTimebaseOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedDividedSampClkTimebaseOutputTerm) DAQmxResetExportedDividedSampClkTimebaseOutputTerm;
int32 __CFUNC DAQmxResetExportedDividedSampClkTimebaseOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_Exported_DataActiveEvent_OutputTerm
 ***/
%rename(GetExportedDataActiveEventOutputTerm) DAQmxGetExportedDataActiveEventOutputTerm;
int32 __CFUNC DAQmxGetExportedDataActiveEventOutputTerm(TaskHandle taskHandle, char *data, uInt32 bufferSize);
%rename(SetExportedDataActiveEventOutputTerm) DAQmxSetExportedDataActiveEventOutputTerm;
int32 __CFUNC DAQmxSetExportedDataActiveEventOutputTerm(TaskHandle taskHandle, const char *data);
%rename(ResetExportedDataActiveEventOutputTerm) DAQmxResetExportedDataActiveEventOutputTerm;
int32 __CFUNC DAQmxResetExportedDataActiveEventOutputTerm(TaskHandle taskHandle);
/*** Set/Get functions for DAQmx_SampTimingEngine
 ***/
%rename(GetSampTimingEngine) DAQmxGetSampTimingEngine;
int32 __CFUNC DAQmxGetSampTimingEngine(TaskHandle taskHandle, uInt32 *data);
%rename(SetSampTimingEngine) DAQmxSetSampTimingEngine;
int32 __CFUNC DAQmxSetSampTimingEngine(TaskHandle taskHandle, uInt32 data);
%rename(ResetSampTimingEngine) DAQmxResetSampTimingEngine;
int32 __CFUNC DAQmxResetSampTimingEngine(TaskHandle taskHandle);


